diff --git a/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateView.h b/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateView.h
index 7009ec6c2e..9bf52d0733 100644
--- a/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateView.h
+++ b/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateView.h
@@ -1,44 +1,44 @@
 $(license)
 
 #ifndef $(view-file-name)_h
 #define $(view-file-name)_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_$(view-file-name)Controls.h"
 
 /**
   \brief $(view-class-name)
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \sa QmitkAbstractView
   \ingroup ${plugin_target}_internal
 */
 class $(view-class-name) : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
 protected:
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   virtual void SetFocus() override;
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
+  /// \brief Overridden from QmitkAbstractView
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
                                   const QList<mitk::DataNode::Pointer> &nodes) override;
 
   /// \brief Called when the user clicks the GUI button
   void DoImageProcessing();
 
   Ui::$(view-file-name)Controls m_Controls;
 };
 
 #endif // $(view-file-name)_h
diff --git a/CMake/BuildConfigurations/WorkbenchRelease.cmake b/CMake/BuildConfigurations/WorkbenchRelease.cmake
index 694b4b9e35..a0742477e2 100644
--- a/CMake/BuildConfigurations/WorkbenchRelease.cmake
+++ b/CMake/BuildConfigurations/WorkbenchRelease.cmake
@@ -1,28 +1,29 @@
 include(${CMAKE_CURRENT_LIST_DIR}/Default.cmake)
 
 set(MITK_CONFIG_PACKAGES ${MITK_CONFIG_PACKAGES}
   MatchPoint
 )
 
 set(MITK_CONFIG_PLUGINS ${MITK_CONFIG_PLUGINS}
   org.mitk.gui.qt.multilabelsegmentation
   org.mitk.matchpoint.core.helper
   org.mitk.gui.qt.matchpoint.algorithm.browser
   org.mitk.gui.qt.matchpoint.algorithm.control
   org.mitk.gui.qt.matchpoint.mapper
   org.mitk.gui.qt.matchpoint.framereg
   org.mitk.gui.qt.matchpoint.visualizer
   org.mitk.gui.qt.matchpoint.evaluator
   org.mitk.gui.qt.matchpoint.manipulator
 )
 
 if(NOT MITK_USE_SUPERBUILD)
   set(BUILD_CoreCmdApps ON CACHE BOOL "" FORCE)
+  set(BUILD_MatchPointCmdApps ON CACHE BOOL "" FORCE)
 endif()
 
 set(MITK_VTK_DEBUG_LEAKS OFF CACHE BOOL "Enable VTK Debug Leaks" FORCE)
 
 find_package(Doxygen REQUIRED)
 
 # Ensure that the in-application help can be build
 set(BLUEBERRY_QT_HELP_REQUIRED ON CACHE BOOL "Required Qt help documentation in plug-ins" FORCE)
diff --git a/CMake/PackageDepends/MITK_nlohmann_json_Config.cmake b/CMake/PackageDepends/MITK_nlohmann_json_Config.cmake
new file mode 100644
index 0000000000..d434c19b31
--- /dev/null
+++ b/CMake/PackageDepends/MITK_nlohmann_json_Config.cmake
@@ -0,0 +1 @@
+set(ALL_LIBRARIES "nlohmann_json::nlohmann_json")
diff --git a/CMake/manifest.xml.in b/CMake/manifest.xml.in
new file mode 100644
index 0000000000..0e42726234
--- /dev/null
+++ b/CMake/manifest.xml.in
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity type="win32" name="${TARGET}" version="6.0.0.0"/>
+  <application>
+    <windowsSettings>
+      <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
+    </windowsSettings>
+  </application>
+</assembly>
diff --git a/CMake/mitkFunctionAddManifest.cmake b/CMake/mitkFunctionAddManifest.cmake
new file mode 100644
index 0000000000..eb9dc117e0
--- /dev/null
+++ b/CMake/mitkFunctionAddManifest.cmake
@@ -0,0 +1,5 @@
+function(mitk_add_manifest TARGET)
+  set(manifest_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.exe.manifest")
+  configure_file("${MITK_SOURCE_DIR}/CMake/manifest.xml.in" "${manifest_file}")
+  target_sources(${TARGET} PRIVATE "${manifest_file}")
+endfunction()
diff --git a/CMake/mitkFunctionCreateBlueBerryApplication.cmake b/CMake/mitkFunctionCreateBlueBerryApplication.cmake
index f31bdfb29d..7c1b5a730e 100644
--- a/CMake/mitkFunctionCreateBlueBerryApplication.cmake
+++ b/CMake/mitkFunctionCreateBlueBerryApplication.cmake
@@ -1,231 +1,235 @@
 #!
 #! Create a BlueBerry application.
 #!
 #! \brief This function will create a BlueBerry application together with all
 #! necessary provisioning and configuration data and install support.
 #!
 #! \param NAME (required) The name of the executable.
 #! \param DESCRIPTION (optional) A human-readable description of your application.
 #!        The usage depends on the CPack generator (on Windows, this is a descriptive
 #!        text for the created shortcuts).
 #! \param SOURCES (optional) A list of source files to compile into your executable. Defaults
 #!        to <name>.cpp.
 #! \param PLUGINS (optional) A list of required plug-ins. Defaults to all known plug-ins.
 #! \param EXCLUDE_PLUGINS (optional) A list of plug-ins which should not be used. Mainly
 #!        useful if PLUGINS was not used.
 #! \param LINK_LIBRARIES A list of libraries to be linked with the executable.
 #! \param LIBRARY_DIRS A list of directories to pass through to MITK_INSTALL_TARGETS
 #! \param NO_PROVISIONING (option) Do not create provisioning files.
 #! \param NO_INSTALL (option) Do not install this executable
 #!
 #! Assuming that there exists a file called <code>MyApp.cpp</code>, an example call looks like:
 #! \code
 #! mitkFunctionCreateBlueBerryApplication(
 #!   NAME MyApp
 #!   DESCRIPTION "MyApp - New ways to explore medical data"
 #!   EXCLUDE_PLUGINS org.mitk.gui.qt.extapplication
 #! )
 #! \endcode
 #!
 function(mitkFunctionCreateBlueBerryApplication)
 
 cmake_parse_arguments(_APP "NO_PROVISIONING;NO_INSTALL" "NAME;DESCRIPTION" "SOURCES;PLUGINS;EXCLUDE_PLUGINS;LINK_LIBRARIES;LIBRARY_DIRS" ${ARGN})
 
 if(NOT _APP_NAME)
   message(FATAL_ERROR "NAME argument cannot be empty.")
 endif()
 
 if(NOT _APP_SOURCES)
   set(_APP_SOURCES ${_APP_NAME}.cpp)
 endif()
 
 if(NOT _APP_PLUGINS)
   ctkFunctionGetAllPluginTargets(_APP_PLUGINS)
 else()
   set(_plugins ${_APP_PLUGINS})
   set(_APP_PLUGINS)
   foreach(_plugin ${_plugins})
     string(REPLACE "." "_" _plugin_target ${_plugin})
     list(APPEND _APP_PLUGINS ${_plugin_target})
   endforeach()
 
   # get all plug-in dependencies
   ctkFunctionGetPluginDependencies(_plugin_deps PLUGINS ${_APP_PLUGINS} ALL)
   # add the dependencies to the list of application plug-ins
   list(APPEND _APP_PLUGINS ${_plugin_deps})
 endif()
 
 # -----------------------------------------------------------------------
 # Set up include and link dirs for the executable
 # -----------------------------------------------------------------------
 
 include_directories(
   ${org_blueberry_core_runtime_INCLUDE_DIRS}
 )
 
 # -----------------------------------------------------------------------
 # Add executable icon (Windows)
 # -----------------------------------------------------------------------
 set(WINDOWS_ICON_RESOURCE_FILE "")
 if(WIN32)
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/icons/${_APP_NAME}.rc")
     set(WINDOWS_ICON_RESOURCE_FILE "${CMAKE_CURRENT_SOURCE_DIR}/icons/${_APP_NAME}.rc")
   endif()
 endif()
 
 # -----------------------------------------------------------------------
 # Create the executable and link libraries
 # -----------------------------------------------------------------------
 
 set(_app_compile_flags )
 if(WIN32)
   set(_app_compile_flags "${_app_compile_flags} -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN")
 endif()
 
 if(MITK_SHOW_CONSOLE_WINDOW)
   add_executable(${_APP_NAME} MACOSX_BUNDLE ${_APP_SOURCES} ${WINDOWS_ICON_RESOURCE_FILE})
 else()
   add_executable(${_APP_NAME} MACOSX_BUNDLE WIN32 ${_APP_SOURCES} ${WINDOWS_ICON_RESOURCE_FILE})
 endif()
 
 if(NOT CMAKE_CURRENT_SOURCE_DIR MATCHES "^${CMAKE_SOURCE_DIR}/.*")
   foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
     if("${CMAKE_CURRENT_SOURCE_DIR}/" MATCHES "^${MITK_EXTENSION_DIR}/.*")
       get_filename_component(MITK_EXTENSION_ROOT_FOLDER "${MITK_EXTENSION_DIR}" NAME)
       set_property(TARGET ${_APP_NAME} PROPERTY FOLDER "${MITK_EXTENSION_ROOT_FOLDER}/Applications")
       break()
     endif()
   endforeach()
 else()
   set_property(TARGET ${_APP_NAME} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Applications")
 endif()
 
 mitk_use_modules(TARGET ${_APP_NAME} MODULES MitkAppUtil)
 
 set_target_properties(${_APP_NAME} PROPERTIES
                       COMPILE_FLAGS "${_app_compile_flags}")
 
 target_link_libraries(${_APP_NAME} PRIVATE org_blueberry_core_runtime ${_APP_LINK_LIBRARIES})
 if(WIN32)
   target_link_libraries(${_APP_NAME} PRIVATE ${QT_QTMAIN_LIBRARY})
 endif()
 
+if(WIN32 AND MITK_UTF8)
+  mitk_add_manifest(${_APP_NAME})
+endif()
+
 # -----------------------------------------------------------------------
 # Add executable icon and bundle name (Mac)
 # -----------------------------------------------------------------------
 if(APPLE)
   if( _APP_DESCRIPTION)
     set_target_properties(${_APP_NAME} PROPERTIES MACOSX_BUNDLE_NAME "${_APP_DESCRIPTION}")
   else()
     set_target_properties(${_APP_NAME} PROPERTIES MACOSX_BUNDLE_NAME "${_APP_NAME}")
   endif()
   set(icon_name "icon.icns")
   set(icon_full_path "${CMAKE_CURRENT_SOURCE_DIR}/icons/${icon_name}")
   if(EXISTS "${icon_full_path}")
     set_target_properties(${_APP_NAME} PROPERTIES MACOSX_BUNDLE_ICON_FILE "${icon_name}")
     file(COPY ${icon_full_path} DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_APP_NAME}.app/Contents/Resources/")
     INSTALL (FILES ${icon_full_path} DESTINATION "${_APP_NAME}.app/Contents/Resources/")
   endif()
 endif()
 
 # -----------------------------------------------------------------------
 # Set build time dependencies
 # -----------------------------------------------------------------------
 
 # This ensures that all enabled plug-ins are up-to-date when the
 # executable is build.
 if(_APP_PLUGINS)
   ctkMacroGetAllProjectTargetLibraries("${_APP_PLUGINS}" _project_plugins)
   if(_APP_EXCLUDE_PLUGINS AND _project_plugins)
     set(_exclude_targets)
     foreach(_exclude_plugin ${_APP_EXCLUDE_PLUGINS})
       string(REPLACE "." "_" _exclude_target ${_exclude_plugin})
       list(APPEND _exclude_targets ${_exclude_target})
     endforeach()
     list(REMOVE_ITEM _project_plugins ${_exclude_targets})
   endif()
   if(_project_plugins)
     add_dependencies(${_APP_NAME} ${_project_plugins})
   endif()
 endif()
 
 # -----------------------------------------------------------------------
 # Additional files needed for the executable
 # -----------------------------------------------------------------------
 
 if(NOT _APP_NO_PROVISIONING)
 
   # Create a provisioning file, listing all plug-ins
   set(_prov_file "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_APP_NAME}.provisioning")
   mitkFunctionCreateProvisioningFile(FILE ${_prov_file}
                                      PLUGINS ${_APP_PLUGINS}
                                      EXCLUDE_PLUGINS ${_APP_EXCLUDE_PLUGINS}
                                     )
 
 endif()
 
 # Create a .ini file for initial parameters
 if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_APP_NAME}.ini")
   configure_file(${_APP_NAME}.ini
                  ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_APP_NAME}.ini)
 endif()
 
 # Create batch and VS user files for Windows platforms
 include(mitkFunctionCreateWindowsBatchScript)
 
 if(WIN32)
   set(template_name "start${_APP_NAME}.bat.in")
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${template_name}")
     foreach(BUILD_TYPE debug release)
       mitkFunctionCreateWindowsBatchScript(${template_name}
         ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/start${_APP_NAME}_${BUILD_TYPE}.bat
         ${BUILD_TYPE})
     endforeach()
   endif()
   mitkFunctionConfigureVisualStudioUserProjectFile(
     NAME ${_APP_NAME}
   )
 endif(WIN32)
 
 # -----------------------------------------------------------------------
 # Install support
 # -----------------------------------------------------------------------
 
 if(NOT _APP_NO_INSTALL)
 
   # This installs all third-party CTK plug-ins
   mitkFunctionInstallThirdPartyCTKPlugins(${_APP_PLUGINS} EXCLUDE ${_APP_EXCLUDE_PLUGINS})
 
   if(COMMAND BlueBerryApplicationInstallHook)
     set(_real_app_plugins ${_APP_PLUGINS})
     if(_APP_EXCLUDE_PLUGINS)
       list(REMOVE_ITEM _real_app_plugins ${_APP_EXCLUDE_PLUGINS})
     endif()
     BlueBerryApplicationInstallHook(APP_NAME ${_APP_NAME} PLUGINS ${_real_app_plugins})
   endif()
 
   # Install the executable
   MITK_INSTALL_TARGETS(EXECUTABLES ${_APP_NAME} LIBRARY_DIRS ${_APP_LIBRARY_DIRS} GLOB_PLUGINS )
 
   if(NOT _APP_NO_PROVISIONING)
     # Install the provisioning file
     mitkFunctionInstallProvisioningFiles(${_prov_file})
   endif()
 
   # On Linux, create a shell script to start a relocatable application
   if(UNIX AND NOT APPLE)
     install(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME "${_APP_NAME}.sh")
   elseif(WIN32)
     install(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledWin32App.bat" DESTINATION "." RENAME "${_APP_NAME}.bat")
   endif()
 
   # Tell cpack the executables that you want in the start menu as links
   set(MITK_CPACK_PACKAGE_EXECUTABLES ${MITK_CPACK_PACKAGE_EXECUTABLES} "${_APP_NAME};${_APP_DESCRIPTION}" CACHE INTERNAL "Collecting windows shortcuts to executables")
 
 endif()
 
 endfunction()
 
 function(FunctionCreateBlueBerryApplication)
   message(SEND_ERROR "The function FunctionCreateBlueBerryApplication was renamed to mitkFunctionCreateBlueBerryApplication in MITK 2015.05")
 endfunction()
diff --git a/CMake/mitkFunctionCreateModule.cmake b/CMake/mitkFunctionCreateModule.cmake
index cfb328b7b4..40e48ef56e 100644
--- a/CMake/mitkFunctionCreateModule.cmake
+++ b/CMake/mitkFunctionCreateModule.cmake
@@ -1,647 +1,650 @@
 ##################################################################
 #
 # mitk_create_module
 #
 #! Creates a module for the automatic module dependency system within MITK.
 #!
 #! Example:
 #!
 #! \code
 #! mitk_create_module(
 #!     DEPENDS PUBLIC MitkCore
 #!     PACKAGE_DEPENDS
 #!       PRIVATE Qt5|Xml+Networking
 #!       PUBLIC  ITK|Watersheds
 #! \endcode
 #!
 #! The <moduleName> parameter specifies the name of the module which is used
 #! to create a logical target name. The parameter is optional in case the
 #! MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME variable evaluates to TRUE. The
 #! module name will then be derived from the directory name in which this
 #! function is called.
 #!
 #! If set, the following variables will be used to validate the module name:
 #!
 #!   MITK_MODULE_NAME_REGEX_MATCH The module name must match this regular expression.
 #!   MITK_MODULE_NAME_REGEX_NOT_MATCH The module name must not match this regular expression.
 #!
 #! If the MITK_MODULE_NAME_PREFIX variable is set, the module name will be prefixed
 #! with its contents.
 #!
 #! A modules source files are specified in a separate CMake file usually
 #! called files.cmake, located in the module root directory. The
 #! mitk_create_module() macro evaluates the following CMake variables
 #! from the files.cmake file:
 #!
 #! - CPP_FILES A list of .cpp files
 #! - H_FILES A list of .h files without a corresponding .cpp file
 #! - TXX_FILES A list of .txx files
 #! - RESOURCE_FILES A list of files (resources) which are embedded into the module
 #! - MOC_H_FILES A list of Qt header files which should be processed by the MOC
 #! - UI_FILES A list of .ui Qt UI files
 #! - QRC_FILES A list of .qrc Qt resource files
 #! - DOX_FILES A list of .dox Doxygen files
 #!
 #! List of variables available after the function is called:
 #! - MODULE_NAME
 #! - MODULE_TARGET
 #! - MODULE_IS_ENABLED
 #!
 #! \sa mitk_create_executable
 #!
 #! Parameters (all optional):
 #!
 #! \param <moduleName> The module name (also used as target name)
 #! \param FILES_CMAKE File name of a CMake file setting source list variables
 #!        (defaults to files.cmake)
 #! \param VERSION Module version number, e.g. "1.2.0"
 #! \param AUTOLOAD_WITH A module target name identifying the module which will
 #!        trigger the automatic loading of this module
 #! \param DEPRECATED_SINCE Marks this modules as deprecated since <arg>
 #! \param DESCRIPTION A description for this module
 #!
 #! Multi-value Parameters (all optional):
 #!
 
 #! \param INCLUDE_DIRS Include directories for this module:
 #!        \verbatim
 #! [[PUBLIC|PRIVATE|INTERFACE] <dir1>...]...
 #! \endverbatim
 #!        The default scope for include directories is PUBLIC.
 #! \param DEPENDS List of module dependencies:
 #!        \verbatim
 #! [[PUBLIC|PRIVATE|INTERFACE] <module1>...]...
 #! \endverbatim
 #!        The default scope for module dependencies is PUBLIC.
 #! \param PACKAGE_DEPENDS List of public packages dependencies (e.g. Qt, VTK, etc.).
 #!        Package dependencies have the following syntax:
 #!        \verbatim
 #! [PUBLIC|PRIVATE|INTERFACE] PACKAGE[|COMPONENT1[+COMPONENT2]...]
 #! \endverbatim
 #!        The default scope for package dependencies is PRIVATE.
 #! \param ADDITIONAL_LIBS List of additional private libraries linked to this module.
 #!        The folder containing the library will be added to the global list of library search paths.
 #! \param CPP_FILES List of source files for this module. If the list is non-empty,
 #!        the module does not need to provide a files.cmake file or FILES_CMAKE argument.
 #! \param H_FILES List of public header files for this module. It is recommended to use
 #!        a files.cmake file instead.
 #!
 #! Options (optional)
 #!
 #! \param FORCE_STATIC Force building this module as a static library
 #! \param GCC_DEFAULT_VISIBILITY Do not use gcc visibility flags - all
 #!        symbols will be exported
 #! \param NO_INIT Do not create CppMicroServices initialization code
 #! \param NO_FEATURE_INFO Do not create a feature info by calling add_feature_info()
 #! \param WARNINGS_NO_ERRORS Do not treat compiler warnings as errors
 #
 ##################################################################
 function(mitk_create_module)
 
   set(_macro_params
       VERSION                # module version number, e.g. "1.2.0"
       EXPORT_DEFINE          # export macro name for public symbols of this module (DEPRECATED)
       AUTOLOAD_WITH          # a module target name identifying the module which will trigger the
                              # automatic loading of this module
       FILES_CMAKE            # file name of a CMake file setting source list variables
                              # (defaults to files.cmake)
       DEPRECATED_SINCE       # marks this modules as deprecated
       DESCRIPTION            # a description for this module
      )
 
   set(_macro_multiparams
       SUBPROJECTS            # list of CDash labels (deprecated)
       INCLUDE_DIRS           # include directories: [PUBLIC|PRIVATE|INTERFACE] <list>
       INTERNAL_INCLUDE_DIRS  # include dirs internal to this module (DEPRECATED)
       DEPENDS                # list of modules this module depends on: [PUBLIC|PRIVATE|INTERFACE] <list>
       DEPENDS_INTERNAL       # list of modules this module internally depends on (DEPRECATED)
       PACKAGE_DEPENDS        # list of "packages this module depends on (e.g. Qt, VTK, etc.): [PUBLIC|PRIVATE|INTERFACE] <package-list>
       TARGET_DEPENDS         # list of CMake targets this module should depend on: [PUBLIC|PRIVATE|INTERFACE] <list>
       ADDITIONAL_LIBS        # list of addidtional private libraries linked to this module.
       CPP_FILES              # list of cpp files
       H_FILES                # list of header files: [PUBLIC|PRIVATE] <list>
      )
 
   set(_macro_options
       FORCE_STATIC           # force building this module as a static library
       HEADERS_ONLY           # this module is a headers-only library
       GCC_DEFAULT_VISIBILITY # do not use gcc visibility flags - all symbols will be exported
       NO_DEFAULT_INCLUDE_DIRS # do not add default include directories like "include" or "."
       NO_INIT                # do not create CppMicroServices initialization code
       NO_FEATURE_INFO        # do not create a feature info by calling add_feature_info()
       WARNINGS_NO_ERRORS     # do not treat compiler warnings as errors
       EXECUTABLE             # create an executable; do not use directly, use mitk_create_executable() instead
       C_MODULE               # compile all source files as C sources
       CXX_MODULE             # compile all source files as C++ sources
      )
 
   cmake_parse_arguments(MODULE "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
 
   set(MODULE_NAME ${MODULE_UNPARSED_ARGUMENTS})
 
   # -----------------------------------------------------------------
   # Sanity checks
 
   if(NOT MODULE_NAME)
     if(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME)
       get_filename_component(MODULE_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)
     else()
       message(SEND_ERROR "The module name must not be empty")
     endif()
   endif()
 
   set(_deprecated_args INTERNAL_INCLUDE_DIRS DEPENDS_INTERNAL EXPORT_DEFINE HEADERS_ONLY)
   foreach(_deprecated_arg ${_deprecated_args})
     if(MODULE_${_deprecated_arg})
       message(WARNING "The ${_deprecated_arg} argument is deprecated")
     endif()
   endforeach()
 
   set(_module_type module)
   set(_Module_type Module)
   if(MODULE_EXECUTABLE)
     set(_module_type executable)
     set(_Module_type Executable)
   endif()
 
   if(MITK_MODULE_NAME_REGEX_MATCH)
     if(NOT ${MODULE_NAME} MATCHES ${MITK_MODULE_NAME_REGEX_MATCH})
       message(SEND_ERROR "The ${_module_type} name \"${MODULE_NAME}\" does not match the regular expression \"${MITK_MODULE_NAME_REGEX_MATCH}\".")
     endif()
   endif()
   if(MITK_MODULE_NAME_REGEX_NOT_MATCH)
     if(${MODULE_NAME} MATCHES ${MITK_MODULE_NAME_REGEX_NOT_MATCH})
       message(SEND_ERROR "The ${_module_type} name \"${MODULE_NAME}\" must not match the regular expression \"${MITK_MODULE_NAME_REGEX_NOT_MATCH}\".")
     endif()
   endif()
 
   if(MITK_MODULE_NAME_PREFIX AND NOT MODULE_NAME MATCHES "^${MITK_MODULE_NAME_PREFIX}.*$")
     set(MODULE_NAME "${MITK_MODULE_NAME_PREFIX}${MODULE_NAME}")
   endif()
 
   if(NOT MODULE_FILES_CMAKE)
     set(MODULE_FILES_CMAKE files.cmake)
   endif()
   if(NOT IS_ABSOLUTE ${MODULE_FILES_CMAKE})
     set(MODULE_FILES_CMAKE ${CMAKE_CURRENT_SOURCE_DIR}/${MODULE_FILES_CMAKE})
   endif()
 
   # -----------------------------------------------------------------
   # Check if module should be build
 
   set(MODULE_TARGET ${MODULE_NAME})
 
   # assume worst case
   set(MODULE_IS_ENABLED 0)
   # first we check if we have an explicit module build list
   if(MITK_MODULES_TO_BUILD)
     list(FIND MITK_MODULES_TO_BUILD ${MODULE_NAME} _MOD_INDEX)
     if(_MOD_INDEX EQUAL -1)
       set(MODULE_IS_EXCLUDED 1)
     endif()
   endif()
 
   if(NOT MODULE_IS_EXCLUDED)
     # first of all we check for the dependencies
     _mitk_parse_package_args(${MODULE_PACKAGE_DEPENDS})
     mitk_check_module_dependencies(MODULES ${MODULE_DEPENDS}
                                    PACKAGES ${PACKAGE_NAMES}
                                    MISSING_DEPENDENCIES_VAR _MISSING_DEP
                                    PACKAGE_DEPENDENCIES_VAR PACKAGE_NAMES)
 
     if(_MISSING_DEP)
       if(MODULE_NO_FEATURE_INFO)
         message("${_Module_type} ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}")
       endif()
       set(MODULE_IS_ENABLED 0)
     else()
       foreach(dep ${MODULE_DEPENDS})
           if(TARGET ${dep})
             get_target_property(AUTLOAD_DEP ${dep} MITK_AUTOLOAD_DIRECTORY)
             if (AUTLOAD_DEP)
               message(SEND_ERROR "Module \"${MODULE_NAME}\" has an invalid dependency on autoload module \"${dep}\". Check MITK_CREATE_MODULE usage for \"${MODULE_NAME}\".")
             endif()
           endif()
       endforeach(dep)
 
       set(MODULE_IS_ENABLED 1)
       # now check for every package if it is enabled. This overlaps a bit with
       # MITK_CHECK_MODULE ...
       foreach(_package ${PACKAGE_NAMES})
         if((DEFINED MITK_USE_${_package}) AND NOT (MITK_USE_${_package}))
           message("${_Module_type} ${MODULE_NAME} won't be built. Turn on MITK_USE_${_package} if you want to use it.")
           set(MODULE_IS_ENABLED 0)
           break()
         endif()
       endforeach()
     endif()
   endif()
 
   # -----------------------------------------------------------------
   # Start creating the module
 
   if(MODULE_IS_ENABLED)
 
     # clear variables defined in files.cmake
     set(RESOURCE_FILES )
     set(CPP_FILES )
     set(H_FILES )
     set(TXX_FILES )
     set(DOX_FILES )
     set(UI_FILES )
     set(MOC_H_FILES )
     set(QRC_FILES )
 
     # clear other variables
     set(Q${KITNAME}_GENERATED_CPP )
     set(Q${KITNAME}_GENERATED_MOC_CPP )
     set(Q${KITNAME}_GENERATED_QRC_CPP )
     set(Q${KITNAME}_GENERATED_UI_CPP )
 
     # check and set-up auto-loading
     if(MODULE_AUTOLOAD_WITH)
       if(NOT TARGET "${MODULE_AUTOLOAD_WITH}")
         message(SEND_ERROR "The module target \"${MODULE_AUTOLOAD_WITH}\" specified as the auto-loading module for \"${MODULE_NAME}\" does not exist")
       endif()
     endif()
     set(_module_autoload_meta_target "${CMAKE_PROJECT_NAME}-autoload")
     # create a meta-target if it does not already exist
     if(NOT TARGET ${_module_autoload_meta_target})
       add_custom_target(${_module_autoload_meta_target})
       set_property(TARGET ${_module_autoload_meta_target} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Modules/Autoload")
     endif()
 
     if(NOT MODULE_EXPORT_DEFINE)
       set(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT)
     endif()
 
     if(MITK_GENERATE_MODULE_DOT)
       message("MODULEDOTNAME ${MODULE_NAME}")
       foreach(dep ${MODULE_DEPENDS})
         message("MODULEDOT \"${MODULE_NAME}\" -> \"${dep}\" ; ")
       endforeach(dep)
     endif(MITK_GENERATE_MODULE_DOT)
 
     if (EXISTS ${MODULE_FILES_CMAKE})
       include(${MODULE_FILES_CMAKE})
     endif()
 
     if(MODULE_CPP_FILES)
       list(APPEND CPP_FILES ${MODULE_CPP_FILES})
     endif()
 
     if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src")
       # Preprend the "src" directory to the cpp file list
       set(_cpp_files ${CPP_FILES})
       set(CPP_FILES )
       foreach(_cpp_file ${_cpp_files})
         list(APPEND CPP_FILES "src/${_cpp_file}")
       endforeach()
     endif()
 
     if(CPP_FILES OR RESOURCE_FILES OR UI_FILES OR MOC_H_FILES OR QRC_FILES)
       set(MODULE_HEADERS_ONLY 0)
       if(MODULE_C_MODULE)
         set_source_files_properties(${CPP_FILES} PROPERTIES LANGUAGE C)
       elseif(MODULE_CXX_MODULE)
         set_source_files_properties(${CPP_FILES} PROPERTIES LANGUAGE CXX)
       endif()
     else()
       set(MODULE_HEADERS_ONLY 1)
       if(MODULE_AUTOLOAD_WITH)
         message(SEND_ERROR "A headers only module cannot be auto-loaded")
       endif()
     endif()
 
     set(module_c_flags )
     set(module_c_flags_debug )
     set(module_c_flags_release )
     set(module_cxx_flags )
     set(module_cxx_flags_debug )
     set(module_cxx_flags_release )
 
     if(MODULE_GCC_DEFAULT_VISIBILITY OR NOT CMAKE_COMPILER_IS_GNUCXX)
       # We only support hidden visibility for gcc for now. Clang still has troubles with
       # correctly marking template declarations and explicit template instantiations as exported.
       # See http://comments.gmane.org/gmane.comp.compilers.clang.scm/50028
       # and http://llvm.org/bugs/show_bug.cgi?id=10113
       set(CMAKE_CXX_VISIBILITY_PRESET default)
       set(CMAKE_VISIBILITY_INLINES_HIDDEN 0)
     else()
       set(CMAKE_CXX_VISIBILITY_PRESET hidden)
       set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
     endif()
 
     if(NOT MODULE_WARNINGS_NO_ERRORS)
       if(MSVC_VERSION)
         mitkFunctionCheckCAndCXXCompilerFlags("/WX" module_c_flags module_cxx_flags)
 	# this would turn on unused parameter warnings, but unfortunately MSVC cannot
 	# distinguish yet between internal and external headers so this would be triggered
 	# a lot by external code. There is support for it on the way so this line could be
 	# reactivated after https://gitlab.kitware.com/cmake/cmake/issues/17904 has been fixed.
         # mitkFunctionCheckCAndCXXCompilerFlags("/w34100" module_c_flags module_cxx_flags)
       else()
         mitkFunctionCheckCAndCXXCompilerFlags(-Werror module_c_flags module_cxx_flags)
 
         # The flag "c++0x-static-nonintegral-init" has been renamed in newer Clang
         # versions to "static-member-init", see
         # http://clang-developers.42468.n3.nabble.com/Wc-0x-static-nonintegral-init-gone-td3999651.html
         #
         # Also, older Clang and seemingly all gcc versions do not warn if unknown
         # "-no-*" flags are used, so CMake will happily append any -Wno-* flag to the
         # command line. This may get confusing if unrelated compiler errors happen and
         # the error output then additionally contains errors about unknown flags (which
         # is not the case if there were no compile errors).
         #
         # So instead of using -Wno-* we use -Wno-error=*, which will be properly rejected by
         # the compiler and if applicable, prints the specific warning as a real warning and
         # not as an error (although -Werror was given).
 
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=c++0x-static-nonintegral-init" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=static-member-init" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=unknown-warning" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=gnu" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=class-memaccess" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=inconsistent-missing-override" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=deprecated-copy" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=cast-function-type" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=deprecated-declarations" module_c_flags module_cxx_flags)
         mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=type-limits" module_c_flags module_cxx_flags)
       endif()
     endif()
 
     if(MODULE_FORCE_STATIC)
       set(_STATIC STATIC)
     else()
       set(_STATIC )
     endif(MODULE_FORCE_STATIC)
 
     if(NOT MODULE_HEADERS_ONLY)
       if(NOT MODULE_NO_INIT OR RESOURCE_FILES)
         find_package(CppMicroServices QUIET NO_MODULE REQUIRED)
       endif()
       if(NOT MODULE_NO_INIT)
         usFunctionGenerateModuleInit(CPP_FILES)
       endif()
 
       set(binary_res_files )
       set(source_res_files )
       if(RESOURCE_FILES)
         if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/resource")
           set(res_dir resource)
         elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Resources")
           set(res_dir Resources)
         else()
           message(SEND_ERROR "Resources specified but ${CMAKE_CURRENT_SOURCE_DIR}/resource directory not found.")
         endif()
         foreach(res_file ${RESOURCE_FILES})
           if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/${res_dir}/${res_file})
             list(APPEND binary_res_files "${res_file}")
           else()
             list(APPEND source_res_files "${res_file}")
           endif()
         endforeach()
 
         # Add a source level dependencies on resource files
         usFunctionGetResourceSource(TARGET ${MODULE_TARGET} OUT CPP_FILES)
       endif()
     endif()
 
     if(MITK_USE_Qt5)
       if(UI_FILES)
         qt5_wrap_ui(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES})
       endif()
       if(MOC_H_FILES)
         qt5_wrap_cpp(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES} OPTIONS -DBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
       endif()
       if(QRC_FILES)
         qt5_add_resources(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES})
       endif()
     endif()
 
     set(Q${KITNAME}_GENERATED_CPP ${Q${KITNAME}_GENERATED_CPP} ${Q${KITNAME}_GENERATED_UI_CPP} ${Q${KITNAME}_GENERATED_MOC_CPP} ${Q${KITNAME}_GENERATED_QRC_CPP})
 
     mitkFunctionOrganizeSources(
       SOURCE ${CPP_FILES}
       HEADER ${H_FILES}
       TXX ${TXX_FILES}
       DOC ${DOX_FILES}
       UI ${UI_FILES}
       QRC ${QRC_FILES}
       MOC ${Q${KITNAME}_GENERATED_MOC_CPP}
       GEN_QRC ${Q${KITNAME}_GENERATED_QRC_CPP}
       GEN_UI ${Q${KITNAME}_GENERATED_UI_CPP}
       )
 
     set(coverage_sources
         ${CPP_FILES} ${H_FILES} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES}
         ${TOOL_CPPS} ${TOOL_GUI_CPPS})
 
     # ---------------------------------------------------------------
     # Create the actual module target
 
     if(MODULE_HEADERS_ONLY)
       add_library(${MODULE_TARGET} INTERFACE)
       # INTERFACE_LIBRARY targets may only have whitelisted properties. The property "FOLDER" is not allowed.
       # set_property(TARGET ${MODULE_TARGET} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Modules")
     else()
       if(MODULE_EXECUTABLE)
         if(MITK_SHOW_CONSOLE_WINDOW)
           set(_SHOW_CONSOLE_OPTION "")
         else()
           set(_SHOW_CONSOLE_OPTION WIN32)
         endif()
         add_executable(${MODULE_TARGET} ${_SHOW_CONSOLE_OPTION}
                        ${MODULE_CPP_FILES} ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP}
                        ${DOX_FILES} ${UI_FILES} ${QRC_FILES} ${WINDOWS_ICON_RESOURCE_FILE})
+        if(WIN32 AND MITK_UTF8)
+          mitk_add_manifest(${MODULE_TARGET})
+        endif()
         set_property(TARGET ${MODULE_TARGET} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Modules/Executables")
         set(_us_module_name main)
       else()
         add_library(${MODULE_TARGET} ${_STATIC}
                     ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP}
                     ${DOX_FILES} ${UI_FILES} ${QRC_FILES})
         set_property(TARGET ${MODULE_TARGET} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Modules")
         set(_us_module_name ${MODULE_TARGET})
       endif()
 
       # Apply properties to the module target.
       target_compile_definitions(${MODULE_TARGET} PRIVATE US_MODULE_NAME=${_us_module_name})
       if(MODULE_C_MODULE)
         if(module_c_flags)
           string(REPLACE " " ";" module_c_flags "${module_c_flags}")
           target_compile_options(${MODULE_TARGET} PRIVATE ${module_c_flags})
         endif()
         if(module_c_flags_debug)
           string(REPLACE " " ";" module_c_flags_debug "${module_c_flags_debug}")
           target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Debug>:${module_c_flags_debug}>)
         endif()
         if(module_c_flags_release)
           string(REPLACE " " ";" module_c_flags_release "${module_c_flags_release}")
           target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Release>:${module_c_flags_release}>)
         endif()
       else()
         if(module_cxx_flags)
           string(REPLACE " " ";" module_cxx_flags "${module_cxx_flags}")
           target_compile_options(${MODULE_TARGET} PRIVATE ${module_cxx_flags})
         endif()
         if(module_cxx_flags_debug)
           string(REPLACE " " ";" module_cxx_flags_debug "${module_cxx_flags_debug}")
           target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Debug>:${module_cxx_flags_debug}>)
         endif()
         if(module_cxx_flags_release)
           string(REPLACE " " ";" module_cxx_flags_release "${module_cxx_flags_release}")
           target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Release>:${module_cxx_flags_release}>)
         endif()
       endif()
 
       set_property(TARGET ${MODULE_TARGET} PROPERTY US_MODULE_NAME ${_us_module_name})
 
       # Add additional library search directories to a global property which
       # can be evaluated by other CMake macros, e.g. our install scripts.
       if(MODULE_ADDITIONAL_LIBS)
         target_link_libraries(${MODULE_TARGET} PRIVATE ${MODULE_ADDITIONAL_LIBS})
         get_property(_mitk_additional_library_search_paths GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
         foreach(_lib_filepath ${MODULE_ADDITIONAL_LIBS})
           get_filename_component(_search_path "${_lib_filepath}" PATH)
           if(_search_path)
             list(APPEND _mitk_additional_library_search_paths "${_search_path}")
           endif()
         endforeach()
         if(_mitk_additional_library_search_paths)
           list(REMOVE_DUPLICATES _mitk_additional_library_search_paths)
           set_property(GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS ${_mitk_additional_library_search_paths})
         endif()
       endif()
 
       # add the target name to a global property which is used in the top-level
       # CMakeLists.txt file to export the target
       set_property(GLOBAL APPEND PROPERTY MITK_MODULE_TARGETS ${MODULE_TARGET})
       if(MODULE_AUTOLOAD_WITH)
         # for auto-loaded modules, adapt the output directory
         add_dependencies(${_module_autoload_meta_target} ${MODULE_TARGET})
         if(WIN32)
           set(_module_output_prop RUNTIME_OUTPUT_DIRECTORY)
         else()
           set(_module_output_prop LIBRARY_OUTPUT_DIRECTORY)
         endif()
         set(_module_output_dir ${CMAKE_${_module_output_prop}}/${MODULE_AUTOLOAD_WITH})
         get_target_property(_module_is_imported ${MODULE_AUTOLOAD_WITH} IMPORTED)
         if(NOT _module_is_imported)
           # if the auto-loading module is not imported, get its location
           # and put the auto-load module relative to it.
           get_target_property(_module_output_dir ${MODULE_AUTOLOAD_WITH} ${_module_output_prop})
           set_target_properties(${MODULE_TARGET} PROPERTIES
                                 ${_module_output_prop} ${_module_output_dir}/${MODULE_AUTOLOAD_WITH})
         else()
           set_target_properties(${MODULE_TARGET} PROPERTIES
                                 ${_module_output_prop} ${CMAKE_${_module_output_prop}}/${MODULE_AUTOLOAD_WITH})
         endif()
         set_target_properties(${MODULE_TARGET} PROPERTIES
                               MITK_AUTOLOAD_DIRECTORY ${MODULE_AUTOLOAD_WITH})
 
         # add the auto-load module name as a property
         set_property(TARGET ${MODULE_AUTOLOAD_WITH} APPEND PROPERTY MITK_AUTOLOAD_TARGETS ${MODULE_TARGET})
       endif()
 
       if(binary_res_files)
         usFunctionAddResources(TARGET ${MODULE_TARGET}
                                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${res_dir}
                                FILES ${binary_res_files})
       endif()
       if(source_res_files)
         usFunctionAddResources(TARGET ${MODULE_TARGET}
                                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${res_dir}
                                FILES ${source_res_files})
       endif()
       if(binary_res_files OR source_res_files)
         usFunctionEmbedResources(TARGET ${MODULE_TARGET})
       endif()
 
       if(MODULE_DEPRECATED_SINCE)
         set_property(TARGET ${MODULE_TARGET} PROPERTY MITK_MODULE_DEPRECATED_SINCE ${MODULE_DEPRECATED_SINCE})
       endif()
 
       # create export macros
       if (NOT MODULE_EXECUTABLE)
         set(_export_macro_name )
         if(MITK_LEGACY_EXPORT_MACRO_NAME)
           set(_export_macro_names
             EXPORT_MACRO_NAME ${MODULE_EXPORT_DEFINE}
             NO_EXPORT_MACRO_NAME ${MODULE_NAME}_NO_EXPORT
             DEPRECATED_MACRO_NAME ${MODULE_NAME}_DEPRECATED
             NO_DEPRECATED_MACRO_NAME ${MODULE_NAME}_NO_DEPRECATED
           )
         endif()
         generate_export_header(${MODULE_NAME}
           ${_export_macro_names}
           EXPORT_FILE_NAME ${MODULE_NAME}Exports.h
         )
       endif()
 
       target_include_directories(${MODULE_TARGET} PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
 
     endif()
 
     # ---------------------------------------------------------------
     # Properties for both header-only and compiled modules
 
     if(MODULE_HEADERS_ONLY)
       set(_module_property_type INTERFACE)
     else()
       set(_module_property_type PUBLIC)
     endif()
 
     if(MODULE_TARGET_DEPENDS)
       target_link_libraries(${MODULE_TARGET} ${MODULE_TARGET_DEPENDS})
     endif()
 
     set(DEPENDS "${MODULE_DEPENDS}")
     if(NOT MODULE_NO_INIT AND NOT MODULE_HEADERS_ONLY)
       # Add a CppMicroServices dependency implicitly, since it is
       # needed for the generated "module initialization" code.
       set(DEPENDS "CppMicroServices;${DEPENDS}")
     endif()
     if(DEPENDS OR MODULE_PACKAGE_DEPENDS)
       mitk_use_modules(TARGET ${MODULE_TARGET}
                        MODULES ${DEPENDS}
                        PACKAGES ${MODULE_PACKAGE_DEPENDS}
                       )
     endif()
 
     # add include directories
     if(MODULE_INTERNAL_INCLUDE_DIRS)
       target_include_directories(${MODULE_TARGET} PRIVATE ${MODULE_INTERNAL_INCLUDE_DIRS})
     endif()
     if(NOT MODULE_NO_DEFAULT_INCLUDE_DIRS)
       if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/include)
         target_include_directories(${MODULE_TARGET} ${_module_property_type} include)
       else()
         target_include_directories(${MODULE_TARGET} ${_module_property_type} .)
       endif()
       if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/src)
         target_include_directories(${MODULE_TARGET} PRIVATE src)
       endif()
     endif()
     target_include_directories(${MODULE_TARGET} ${_module_property_type} ${MODULE_INCLUDE_DIRS})
 
   endif()
 
   # -----------------------------------------------------------------
   # Record missing dependency information
 
   if(_MISSING_DEP)
     if(MODULE_DESCRIPTION)
       set(MODULE_DESCRIPTION "${MODULE_DESCRIPTION} (missing dependencies: ${_MISSING_DEP})")
     else()
       set(MODULE_DESCRIPTION "(missing dependencies: ${_MISSING_DEP})")
     endif()
   endif()
   if(NOT MODULE_NO_FEATURE_INFO)
     add_feature_info(${MODULE_NAME} MODULE_IS_ENABLED "${MODULE_DESCRIPTION}")
   endif()
 
   set(MODULE_NAME ${MODULE_NAME} PARENT_SCOPE)
   set(MODULE_TARGET ${MODULE_TARGET} PARENT_SCOPE)
   set(MODULE_IS_ENABLED ${MODULE_IS_ENABLED} PARENT_SCOPE)
 
 endfunction()
diff --git a/CMakeExternals/ExternalProjectList.cmake b/CMakeExternals/ExternalProjectList.cmake
index e275f8b0f4..afff18b5ec 100644
--- a/CMakeExternals/ExternalProjectList.cmake
+++ b/CMakeExternals/ExternalProjectList.cmake
@@ -1,32 +1,33 @@
 mitkFunctionAddExternalProject(NAME Poco ON COMPONENTS Foundation Net Util XML Zip)
 mitkFunctionAddExternalProject(NAME DCMTK ON DOC "EXPERIMENTAL, superbuild only: Use DCMTK in MITK")
 mitkFunctionAddExternalProject(NAME OpenIGTLink OFF)
 mitkFunctionAddExternalProject(NAME tinyxml2 ON ADVANCED)
 mitkFunctionAddExternalProject(NAME GDCM ON ADVANCED)
 mitkFunctionAddExternalProject(NAME Eigen ON ADVANCED DOC "Use the Eigen library")
 mitkFunctionAddExternalProject(NAME ANN ON ADVANCED DOC "Use Approximate Nearest Neighbor Library")
 mitkFunctionAddExternalProject(NAME CppUnit ON ADVANCED DOC "Use CppUnit for unit tests")
 mitkFunctionAddExternalProject(NAME HDF5 ON ADVANCED)
 mitkFunctionAddExternalProject(NAME OpenCV OFF)
 mitkFunctionAddExternalProject(NAME Vigra OFF DEPENDS HDF5)
 mitkFunctionAddExternalProject(NAME ITK ON NO_CACHE DEPENDS HDF5)
 mitkFunctionAddExternalProject(NAME VTK ON NO_CACHE)
 mitkFunctionAddExternalProject(NAME Boost ON NO_CACHE)
 mitkFunctionAddExternalProject(NAME ZLIB OFF ADVANCED)
 mitkFunctionAddExternalProject(NAME lz4 ON ADVANCED)
 mitkFunctionAddExternalProject(NAME cpprestsdk OFF DEPENDS Boost ZLIB ADVANCED)
 mitkFunctionAddExternalProject(NAME OpenMesh OFF)
 mitkFunctionAddExternalProject(NAME CTK ON DEPENDS Qt5 DCMTK DOC "Use CTK in MITK")
 mitkFunctionAddExternalProject(NAME DCMQI ON DEPENDS DCMTK ITK DOC "Use dcmqi in MITK")
 mitkFunctionAddExternalProject(NAME MatchPoint OFF ADVANCED DEPENDS ITK DOC "Use the MatchPoint translation image registration library")
+mitkFunctionAddExternalProject(NAME nlohmann_json ON ADVANCED)
 
 if(MITK_USE_Qt5)
  mitkFunctionAddExternalProject(NAME Qwt ON ADVANCED DEPENDS Qt5)
 endif()
 
 if(UNIX AND NOT APPLE)
   mitkFunctionAddExternalProject(NAME PCRE OFF ADVANCED NO_PACKAGE)
   mitkFunctionAddExternalProject(NAME SWIG OFF ADVANCED NO_PACKAGE DEPENDS PCRE)
 elseif(WIN32)
   mitkFunctionAddExternalProject(NAME SWIG OFF ADVANCED NO_PACKAGE)
 endif()
diff --git a/CMakeExternals/nlohmann_json.cmake b/CMakeExternals/nlohmann_json.cmake
new file mode 100644
index 0000000000..fbca098b3c
--- /dev/null
+++ b/CMakeExternals/nlohmann_json.cmake
@@ -0,0 +1,48 @@
+#-----------------------------------------------------------------------------
+# nlohmann_json
+#-----------------------------------------------------------------------------
+
+if(MITK_USE_nlohmann_json)
+  # Sanity checks
+  if(DEFINED nlohmann_json_DIR AND NOT EXISTS "${nlohmann_json_DIR}")
+    message(FATAL_ERROR "nlohmann_json_DIR variable is defined but corresponds to non-existing directory")
+  endif()
+
+  set(proj nlohmann_json)
+  set(proj_DEPENDENCIES )
+  set(nlohmann_json_DEPENDS ${proj})
+
+  if(NOT DEFINED nlohmann_json_DIR)
+
+    set(additional_args )
+
+    if(CTEST_USE_LAUNCHERS)
+      list(APPEND additional_args
+        "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
+      )
+    endif()
+
+    ExternalProject_Add(${proj}
+      LIST_SEPARATOR ${sep}
+      GIT_REPOSITORY https://github.com/nlohmann/json.git
+      GIT_TAG v3.10.5
+      CMAKE_GENERATOR ${gen}
+      CMAKE_GENERATOR_PLATFORM ${gen_platform}
+      CMAKE_ARGS
+        ${ep_common_args}
+        ${additional_args}
+      CMAKE_CACHE_ARGS
+        ${ep_common_cache_args}
+        -DJSON_BuildTests:BOOL=OFF
+      CMAKE_CACHE_DEFAULT_ARGS
+        ${ep_common_cache_default_args}
+      DEPENDS ${proj_DEPENDENCIES}
+    )
+
+    set(nlohmann_json_DIR "${ep_prefix}")
+    mitkFunctionInstallExternalCMakeProject(${proj})
+
+  else()
+    mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+  endif()
+endif()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index dd4c0eec9a..e93e378827 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,1421 +1,1428 @@
 #[[ When increasing the minimum required version, check if Boost_ADDITIONAL_VERSIONS
     in CMake/PackageDepends/MITK_Boost_Config.cmake can be removed. See the first
     long comment in CMakeExternals/Boost.cmake for details. ]]
 
 set(MITK_CMAKE_MINIMUM_REQUIRED_VERSION 3.18)
 cmake_minimum_required(VERSION ${MITK_CMAKE_MINIMUM_REQUIRED_VERSION})
 
 if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.19 AND CMAKE_VERSION VERSION_LESS 3.19.2)
   message(FATAL_ERROR "\
 CMake v${CMAKE_VERSION} is defective [1]. \
 Please either downgrade to v3.18 or upgrade to at least v3.19.2.\n\
 [1] https://gitlab.kitware.com/cmake/cmake/-/issues/21529")
 endif()
 
 #-----------------------------------------------------------------------------
 # Policies
 #-----------------------------------------------------------------------------
 
 #[[ T28060
 
     https://cmake.org/cmake/help/v3.18/policy/CMP0091.html
     https://cmake.org/cmake/help/v3.18/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html
 
     We pass CMP0091 to all external projects as command-line argument:
       -DCMAKE_POLICY_DEFAULT_CMP0091:STRING=OLD
  ]]
 cmake_policy(SET CMP0091 OLD)
 
 #-----------------------------------------------------------------------------
 # Superbuild Option - Enabled by default
 #-----------------------------------------------------------------------------
 
 option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON)
 
 if(MITK_USE_SUPERBUILD)
   project(MITK-superbuild)
   set(MITK_SOURCE_DIR ${PROJECT_SOURCE_DIR})
   set(MITK_BINARY_DIR ${PROJECT_BINARY_DIR})
 else()
-  project(MITK VERSION 2022.04.00)
+  project(MITK VERSION 2022.04.99)
   include_directories(SYSTEM ${MITK_SUPERBUILD_BINARY_DIR})
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK Extension Feature
 #-----------------------------------------------------------------------------
 
 set(MITK_EXTENSION_DIRS "" CACHE STRING "")
 
 unset(MITK_ABSOLUTE_EXTENSION_DIRS)
 
 foreach(MITK_EXTENSION_DIR ${MITK_EXTENSION_DIRS})
   get_filename_component(MITK_ABSOLUTE_EXTENSION_DIR "${MITK_EXTENSION_DIR}" ABSOLUTE)
   list(APPEND MITK_ABSOLUTE_EXTENSION_DIRS "${MITK_ABSOLUTE_EXTENSION_DIR}")
 endforeach()
 
 set(MITK_DIR_PLUS_EXTENSION_DIRS "${MITK_SOURCE_DIR}" ${MITK_ABSOLUTE_EXTENSION_DIRS})
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #-----------------------------------------------------------------------------
 
 set(MITK_CMAKE_DIR ${MITK_SOURCE_DIR}/CMake)
 
 set(CMAKE_MODULE_PATH ${MITK_CMAKE_DIR})
 
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   set(MITK_CMAKE_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMake")
   if(EXISTS "${MITK_CMAKE_EXTENSION_DIR}")
     list(APPEND CMAKE_MODULE_PATH "${MITK_CMAKE_EXTENSION_DIR}")
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 # Standard CMake macros
 include(FeatureSummary)
 include(CTest)
 include(CMakeParseArguments)
 include(FindPackageHandleStandardArgs)
 
 # MITK macros
 include(mitkFunctionGetGccVersion)
 include(mitkFunctionCheckCompilerFlags)
 include(mitkFunctionSuppressWarnings) # includes several functions
 include(mitkMacroEmptyExternalProject)
 include(mitkFunctionEnableBuildConfiguration)
 include(mitkFunctionWhitelists)
 include(mitkFunctionAddExternalProject)
 include(mitkFunctionAddLibrarySearchPaths)
 
 SUPPRESS_VC_DEPRECATED_WARNINGS()
 
 #-----------------------------------------------------------------------------
 # Set a default build type if none was specified
 #-----------------------------------------------------------------------------
 
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(STATUS "Setting build type to 'Debug' as none was specified.")
   set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
 
   # Set the possible values of build type for cmake-gui
   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY
                STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
 endif()
 
 #-----------------------------------------------------------------------------
 # Check miminum macOS version
 #-----------------------------------------------------------------------------
 # The minimum supported macOS version is 10.14. If you use a version less than
 # 10.14, there is no guarantee that the build still works.
 if(APPLE)
   exec_program(sw_vers ARGS -productVersion OUTPUT_VARIABLE macos_version)
   if (macos_version VERSION_LESS "10.14")
     message(WARNING "Detected macOS version \"${macos_version}\" is not supported anymore. Minimum required macOS version is at least 10.14.")
   endif()
   if (CMAKE_OSX_DEPLOYMENT_TARGET AND CMAKE_OSX_DEPLOYMENT_TARGET VERSION_LESS 10.14)
     message(WARNING "Detected macOS deployment target \"${CMAKE_OSX_DEPLOYMENT_TARGET}\" is not supported anymore. Minimum required macOS version is at least 10.14.")
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Check miminum compiler versions
 #-----------------------------------------------------------------------------
 
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
   # require at least gcc 4.9 as provided by ppa:ubuntu-toolchain-r/test for Ubuntu 14.04
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
     message(FATAL_ERROR "GCC version must be at least 4.9
 If you are using Ubuntu 14.04, you can easily install gcc and g++ 4.9 (or any later version available) in addition to your version ${CMAKE_CXX_COMPILER_VERSION}:
   sudo add-apt-repository ppa:ubuntu-toolchain-r/test
   sudo apt-get update
   sudo apt-get install gcc-4.9 g++-4.9
 Make sure to explicitly specify these compilers when configuring MITK:
   CMAKE_C_COMPILER:FILEPATH=/usr/bin/gcc-4.9
   CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/g++-4.9
 For more information on the proposed PPA see the Toolchain Updates section of https://wiki.ubuntu.com/ToolChain.")
   endif()
 elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
   # require at least clang 3.4
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
     message(FATAL_ERROR "Clang version must be at least 3.4")
   endif()
 elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
   # require at least clang 5.0
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
     message(FATAL_ERROR "Apple Clang version must be at least 5.0")
   endif()
 elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
   # require at least Visual Studio 2017
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10)
     message(FATAL_ERROR "Microsoft Visual Studio 2017 or newer required")
   endif()
 else()
   message(WARNING "You are using an unsupported compiler! Compilation has only been tested with Clang (Linux or Apple), GCC and MSVC.")
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
 else()
   set(GCC_VERSION 0)
 endif()
 
 set(MITK_CXX_STANDARD 17)
 
 set(CMAKE_CXX_EXTENSIONS 0)
 set(CMAKE_CXX_STANDARD ${MITK_CXX_STANDARD})
 set(CMAKE_CXX_STANDARD_REQUIRED 1)
 
 # This is necessary to avoid problems with compile feature checks.
 # CMAKE_CXX_STANDARD seems to only set the -std=c++<std> flag for targets.
 # However, compile flag checks also need to be done with -std=c++<std>.
 # The MITK_CXX<std>_FLAG variable is also used for external projects
 # build during the MITK super-build.
 mitkFunctionCheckCompilerFlags("-std=c++${MITK_CXX_STANDARD}" MITK_CXX${MITK_CXX_STANDARD}_FLAG)
 
 #-----------------------------------------------------------------------------
 # Warn if source or build path is too long
 #-----------------------------------------------------------------------------
 
 if(WIN32)
   set(_src_dir_length_max 50)
   set(_bin_dir_length_max 50)
   if(MITK_USE_SUPERBUILD)
     set(_src_dir_length_max 34) # _src_dir_length_max - strlen(ep/src/ITK-build)
     set(_bin_dir_length_max 40) # _bin_dir_length_max - strlen(MITK-build)
   endif()
 
   string(LENGTH "${MITK_SOURCE_DIR}" _src_n)
   string(LENGTH "${MITK_BINARY_DIR}" _bin_n)
 
   # The warnings should be converted to errors
   if(_src_n GREATER _src_dir_length_max)
     message(WARNING "MITK source code directory path length is too long (${_src_n} > ${_src_dir_length_max})."
                     "Please move the MITK source code directory to a directory with a shorter path." )
   endif()
   if(_bin_n GREATER _bin_dir_length_max)
     message(WARNING "MITK build directory path length is too long (${_bin_n} > ${_bin_dir_length_max})."
                     "Please move the MITK build directory to a directory with a shorter path." )
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Additional MITK Options (also shown during superbuild)
 #-----------------------------------------------------------------------------
 
 # -----------------------------------------
 # General build options
 option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON)
 option(WITH_COVERAGE "Enable/Disable coverage" OFF)
 option(BUILD_TESTING "Test the project" ON)
 option(MITK_FAST_TESTING "Disable long-running tests like packaging" OFF)
 option(MITK_XVFB_TESTING "Execute test drivers through xvfb-run" OFF)
 
 option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF)
 option(MITK_BUILD_EXAMPLES "Build the MITK Examples" OFF)
 
 mark_as_advanced(
   MITK_XVFB_TESTING
   MITK_FAST_TESTING
   MITK_BUILD_ALL_APPS
 )
 
 #-----------------------------------------------------------------------------
 # Set UI testing flags
 #-----------------------------------------------------------------------------
 if(MITK_XVFB_TESTING)
   set(MITK_XVFB_TESTING_COMMAND "xvfb-run" "--auto-servernum" CACHE STRING "Command and options to test through Xvfb")
   mark_as_advanced(MITK_XVFB_TESTING_COMMAND)
 endif(MITK_XVFB_TESTING)
 
 # -----------------------------------------
 # Other options
 set(MITK_CUSTOM_REVISION_DESC "" CACHE STRING "Override MITK revision description")
 mark_as_advanced(MITK_CUSTOM_REVISION_DESC)
 
 set_property(GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS "")
 
 include(CMakeExternals/ExternalProjectList.cmake)
 
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   set(MITK_CMAKE_EXTERNALS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMakeExternals")
   if(EXISTS "${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/ExternalProjectList.cmake")
     include("${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/ExternalProjectList.cmake")
   endif()
 endforeach()
 
 # -----------------------------------------
 # Other MITK_USE_* options not related to
 # external projects build via the
 # MITK superbuild
 
 option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
 option(MITK_USE_OpenCL "Use OpenCL GPU-Computing library" OFF)
 option(MITK_USE_OpenMP "Use OpenMP" OFF)
 option(MITK_USE_Python3 "Use Python 3" OFF)
 
 #-----------------------------------------------------------------------------
 # Build configurations
 #-----------------------------------------------------------------------------
 
 set(_buildConfigs "Custom")
 
 file(GLOB _buildConfigFiles CMake/BuildConfigurations/*.cmake)
 
 foreach(_buildConfigFile ${_buildConfigFiles})
   get_filename_component(_buildConfigFile ${_buildConfigFile} NAME_WE)
   list(APPEND _buildConfigs ${_buildConfigFile})
 endforeach()
 
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   file(GLOB _extBuildConfigFiles "${MITK_EXTENSION_DIR}/CMake/BuildConfigurations/*.cmake")
 
   foreach(_extBuildConfigFile ${_extBuildConfigFiles})
     get_filename_component(_extBuildConfigFile "${_extBuildConfigFile}" NAME_WE)
     list(APPEND _buildConfigs "${_extBuildConfigFile}")
   endforeach()
 
   list(REMOVE_DUPLICATES _buildConfigs)
 endforeach()
 
 set(MITK_BUILD_CONFIGURATION "Custom" CACHE STRING "Use pre-defined MITK configurations")
 set_property(CACHE MITK_BUILD_CONFIGURATION PROPERTY STRINGS ${_buildConfigs})
 
 mitkFunctionEnableBuildConfiguration()
 
 mitkFunctionCreateWhitelistPaths(MITK)
 mitkFunctionFindWhitelists(MITK)
 
 # -----------------------------------------
 # Qt version related variables
 
 option(MITK_USE_Qt5 "Use Qt 5 library" ON)
 
 if(MITK_USE_Qt5)
   if(WIN32)
     set(MITK_QT5_MINIMUM_VERSION 5.12.9)
   else()
     set(MITK_QT5_MINIMUM_VERSION 5.12)
   endif()
   set(MITK_QT5_COMPONENTS Concurrent OpenGL PrintSupport Script Sql Svg Widgets Xml XmlPatterns WebEngineWidgets UiTools Help LinguistTools)
   if(APPLE)
     list(APPEND MITK_QT5_COMPONENTS DBus)
   elseif(UNIX)
     list(APPEND MITK_QT5_COMPONENTS X11Extras)
   endif()
 
   # Hint at default install locations of Qt
   if(NOT Qt5_DIR)
     if(MSVC)
       set(_dir_candidates "C:/Qt")
 
       if(CMAKE_GENERATOR MATCHES "^Visual Studio [0-9]+ ([0-9]+)")
         set(_compilers "msvc${CMAKE_MATCH_1}")
       elseif(CMAKE_GENERATOR MATCHES "Ninja")
         include(mitkFunctionGetMSVCVersion)
         mitkFunctionGetMSVCVersion()
         if(VISUAL_STUDIO_PRODUCT_NAME MATCHES "^Visual Studio ([0-9]+)")
           set(_compilers "msvc${CMAKE_MATCH_1}")
         endif()
       endif()
 
       if(_compilers MATCHES "[0-9]+")
         if (CMAKE_MATCH_0 EQUAL 2022)
           list(APPEND _compilers "msvc2019" "msvc2017") # Binary compatible
         elseif (CMAKE_MATCH_0 EQUAL 2019)
           list(APPEND _compilers "msvc2017") # Binary compatible
         endif()
       endif()
     else()
       set(_dir_candidates ~/Qt)
 
       if(APPLE)
         set(_compilers clang)
       else()
         list(APPEND _dir_candidates /opt/Qt)
         set(_compilers gcc)
       endif()
     endif()
 
     if(CMAKE_SIZEOF_VOID_P EQUAL 8)
       foreach(_compiler ${_compilers})
         list(APPEND _compilers64 "${_compiler}_64")
       endforeach()
       set(_compilers ${_compilers64})
     endif()
 
     foreach(_dir_candidate ${_dir_candidates})
       get_filename_component(_dir_candidate ${_dir_candidate} REALPATH)
       foreach(_compiler ${_compilers})
         set(_glob_expression "${_dir_candidate}/5.*/${_compiler}")
         file(GLOB _hints ${_glob_expression})
         list(SORT _hints)
         list(APPEND MITK_QT5_HINTS ${_hints})
       endforeach()
     endforeach()
   endif()
 
   find_package(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS} REQUIRED HINTS ${MITK_QT5_HINTS})
 endif()
 
 # -----------------------------------------
 # Custom dependency logic
 
 if(WIN32 AND Qt5_DIR)
   set(_dir_candidate "${Qt5_DIR}/../../../../../Tools/OpenSSL/Win_x64")
   get_filename_component(_dir_candidate ${_dir_candidate} ABSOLUTE)
   if(EXISTS "${_dir_candidate}")
     set(OPENSSL_ROOT_DIR "${_dir_candidate}")
   endif()
 endif()
 
 find_package(OpenSSL)
 
 option(MITK_USE_SYSTEM_Boost "Use the system Boost" OFF)
 
 set(MITK_USE_Boost_LIBRARIES "" CACHE STRING "A semi-colon separated list of required Boost libraries")
 
 if(MITK_USE_cpprestsdk)
   if(NOT OpenSSL_FOUND)
     set(openssl_message "Could not find OpenSSL (dependency of C++ REST SDK).\n")
     if(UNIX)
       if(APPLE)
         set(openssl_message "${openssl_message}Please install it using your favorite package management "
                             "system (i.e. Homebrew or MacPorts).\n")
       else()
         set(openssl_message "${openssl_message}Please install the dev package of OpenSSL (i.e. libssl-dev).\n")
       endif()
     else()
       set(openssl_message "${openssl_message}Please either install Win32 OpenSSL:\n"
                           "  https://slproweb.com/products/Win32OpenSSL.html\n"
                           "Or use the Qt Maintenance tool to install:\n"
                           "  Developer and Designer Tools > OpenSSL Toolkit > OpenSSL 64-bit binaries\n")
     endif()
     set(openssl_message "${openssl_message}If it still cannot be found, you can hint CMake to find OpenSSL by "
                         "adding/setting the OPENSSL_ROOT_DIR variable to the root directory of an "
                         "OpenSSL installation. Make sure to clear variables of partly found "
                         "versions of OpenSSL before, or they will be mixed up.")
     message(FATAL_ERROR ${openssl_message})
   endif()
 
   list(APPEND MITK_USE_Boost_LIBRARIES date_time regex system)
   if(UNIX)
     list(APPEND MITK_USE_Boost_LIBRARIES atomic chrono filesystem random thread)
   endif()
   list(REMOVE_DUPLICATES MITK_USE_Boost_LIBRARIES)
   set(MITK_USE_Boost_LIBRARIES ${MITK_USE_Boost_LIBRARIES} CACHE STRING "A semi-colon separated list of required Boost libraries" FORCE)
 endif()
 
 if(MITK_USE_Python3)
   set(MITK_USE_ZLIB ON CACHE BOOL "" FORCE)
 
   if(APPLE AND CMAKE_FRAMEWORK_PATH AND CMAKE_FRAMEWORK_PATH MATCHES "python3\\.?([0-9]+)")
     find_package(Python3 3.${CMAKE_MATCH_1} EXACT REQUIRED COMPONENTS Interpreter Development NumPy)
   else()
     find_package(Python3 REQUIRED COMPONENTS Interpreter Development NumPy)
   endif()
 
   if(WIN32)
     string(REPLACE "\\" "/" Python3_STDARCH "${Python3_STDARCH}")
     string(REPLACE "\\" "/" Python3_STDLIB "${Python3_STDLIB}")
     string(REPLACE "\\" "/" Python3_SITELIB "${Python3_SITELIB}")
   endif()
 endif()
 
 if(BUILD_TESTING AND NOT MITK_USE_CppUnit)
   message("> Forcing MITK_USE_CppUnit to ON because BUILD_TESTING=ON")
   set(MITK_USE_CppUnit ON CACHE BOOL "Use CppUnit for unit tests" FORCE)
 endif()
 
 if(MITK_USE_BLUEBERRY)
   option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
   mark_as_advanced(MITK_BUILD_ALL_PLUGINS)
 
   if(NOT MITK_USE_CTK)
     message("> Forcing MITK_USE_CTK to ON because of MITK_USE_BLUEBERRY")
     set(MITK_USE_CTK ON CACHE BOOL "Use CTK in MITK" FORCE)
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Pixel type multiplexing
 #-----------------------------------------------------------------------------
 
 # Customize the default pixel types for multiplex macros
 
 set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
     "int, unsigned int, short, unsigned short, char, unsigned char"
     CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
     "double, float"
     CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
     "itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
     CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_DIMENSIONS
     "2,3"
     CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 
 mark_as_advanced(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
                  MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
                  MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
                  MITK_ACCESSBYITK_DIMENSIONS
                 )
 
 # consistency checks
 
 if(NOT MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
       "int, unsigned int, short, unsigned short, char, unsigned char"
       CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
       "double, float"
       CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
     "itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
     CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES)
   string(REPLACE "," ";" _integral_types ${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES})
   string(REPLACE "," ";" _floating_types ${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES})
   foreach(_scalar_type ${_integral_types} ${_floating_types})
     set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES
         "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}itk::VariableLengthVector<${_scalar_type}>,")
   endforeach()
   string(LENGTH "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" _length)
   math(EXPR _length "${_length} - 1")
   string(SUBSTRING "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" 0 ${_length} MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES ${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
       CACHE STRING "List of vector pixel types used in AccessByItk and InstantiateAccessFunction macros for itk::VectorImage types" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_DIMENSIONS)
   set(MITK_ACCESSBYITK_DIMENSIONS
       "2,3"
       CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 endif()
 
 find_package(Git REQUIRED)
 
 #-----------------------------------------------------------------------------
 # Superbuild script
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_SUPERBUILD)
   include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
 
   # Print configuration summary
   message("\n\n")
   feature_summary(
     DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------"
     WHAT ALL)
   return()
 endif()
 
 #*****************************************************************************
 #****************************  END OF SUPERBUILD  ****************************
 #*****************************************************************************
 
 #-----------------------------------------------------------------------------
 # Organize MITK targets in folders
 #-----------------------------------------------------------------------------
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 set(MITK_ROOT_FOLDER "MITK" CACHE STRING "")
 mark_as_advanced(MITK_ROOT_FOLDER)
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(WriteBasicConfigVersionFile)
 include(CheckCXXSourceCompiles)
 include(GenerateExportHeader)
 
+include(mitkFunctionAddManifest)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkFunctionCheckModuleDependencies)
 include(mitkFunctionCompileSnippets)
 include(mitkFunctionConfigureVisualStudioUserProjectFile)
 include(mitkFunctionCreateBlueBerryApplication)
 include(mitkFunctionCreateCommandLineApp)
 include(mitkFunctionCreateModule)
 include(mitkFunctionCreatePlugin)
 include(mitkFunctionCreateProvisioningFile)
 include(mitkFunctionGetLibrarySearchPaths)
 include(mitkFunctionGetVersion)
 include(mitkFunctionGetVersionDescription)
 include(mitkFunctionInstallAutoLoadModules)
 include(mitkFunctionInstallCTKPlugin)
 include(mitkFunctionInstallProvisioningFiles)
 include(mitkFunctionInstallThirdPartyCTKPlugins)
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionUseModules)
 if( ${MITK_USE_MatchPoint} )
   include(mitkFunctionCreateMatchPointDeployedAlgorithm)
 endif()
 include(mitkMacroConfigureItkPixelTypes)
 include(mitkMacroCreateExecutable)
 include(mitkMacroCreateModuleTests)
 include(mitkMacroGenerateToolsLibrary)
 include(mitkMacroGetLinuxDistribution)
 include(mitkMacroGetPMDPlatformString)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroMultiplexPicType)
 
 # Deprecated
 include(mitkMacroCreateCTKPlugin)
 
 #-----------------------------------------------------------------------------
 # Global CMake variables
 #-----------------------------------------------------------------------------
 
 if(NOT DEFINED CMAKE_DEBUG_POSTFIX)
   # We can't do this yet because the CTK Plugin Framework
   # cannot cope with a postfix yet.
   #set(CMAKE_DEBUG_POSTFIX d)
 endif()
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 set(_default_LIBRARY_output_dir lib)
 set(_default_RUNTIME_output_dir bin)
 set(_default_ARCHIVE_output_dir lib)
 
 foreach(type LIBRARY RUNTIME ARCHIVE)
   # Make sure the directory exists
   if(MITK_CMAKE_${type}_OUTPUT_DIRECTORY
      AND NOT EXISTS ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     message("Creating directory MITK_CMAKE_${type}_OUTPUT_DIRECTORY: ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}")
     file(MAKE_DIRECTORY "${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}")
   endif()
 
   if(MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
     set(CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
   else()
     set(CMAKE_${type}_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${_default_${type}_output_dir})
     set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY})
   endif()
 
   set(CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY} CACHE INTERNAL "Output directory for ${type} files.")
   mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Set MITK specific options and variables (NOT available during superbuild)
 #-----------------------------------------------------------------------------
 
 if(OpenSSL_FOUND AND WIN32)
   set(MITK_OPENSSL_SSL_DLL "" CACHE FILEPATH "")
   set(MITK_OPENSSL_CRYPTO_DLL "" CACHE FILEPATH "")
 
   if(MITK_OPENSSL_SSL_DLL AND EXISTS "${MITK_OPENSSL_SSL_DLL}" AND MITK_OPENSSL_CRYPTO_DLL AND EXISTS "${MITK_OPENSSL_CRYPTO_DLL}")
     foreach(config_type ${CMAKE_CONFIGURATION_TYPES})
       execute_process(COMMAND "${CMAKE_COMMAND}" -E make_directory "${MITK_BINARY_DIR}/bin/${config_type}")
       configure_file("${MITK_OPENSSL_SSL_DLL}" "${MITK_BINARY_DIR}/bin/${config_type}/" COPYONLY)
       configure_file("${MITK_OPENSSL_CRYPTO_DLL}" "${MITK_BINARY_DIR}/bin/${config_type}/" COPYONLY)
     endforeach()
 
     MITK_INSTALL(FILES
       "${MITK_OPENSSL_SSL_DLL}"
       "${MITK_OPENSSL_CRYPTO_DLL}"
     )
   endif()
 endif()
 
 # Look for optional Doxygen package
 find_package(Doxygen)
 
 option(BLUEBERRY_DEBUG_SMARTPOINTER "Enable code for debugging smart pointers" OFF)
 mark_as_advanced(BLUEBERRY_DEBUG_SMARTPOINTER)
 
 # Ask the user to show the console window for applications
 option(MITK_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting MITK GUI Applications" ON)
 mark_as_advanced(MITK_SHOW_CONSOLE_WINDOW)
 
+# As of Windows 10 Version 1903 (May 2019 Update), applications can use the UTF-8 code page
+if(WIN32)
+  option(MITK_UTF8 "Use UTF-8 code page in MITK applications on Windows" ON)
+  mark_as_advanced(MITK_UTF8)
+endif()
+
 if(NOT MITK_FAST_TESTING)
   if(MITK_CTEST_SCRIPT_MODE STREQUAL "Continuous" OR MITK_CTEST_SCRIPT_MODE STREQUAL "Experimental")
     set(MITK_FAST_TESTING ON)
   endif()
 endif()
 
 if(NOT UNIX)
   set(MITK_WIN32_FORCE_STATIC "STATIC" CACHE INTERNAL "Use this variable to always build static libraries on non-unix platforms")
 endif()
 
 if(MITK_BUILD_ALL_PLUGINS)
   set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
 endif()
 
 # Configure pixel types used for ITK image access multiplexing
 mitkMacroConfigureItkPixelTypes()
 
 # Configure module naming conventions
 set(MITK_MODULE_NAME_REGEX_MATCH "^[A-Z].*$")
 set(MITK_MODULE_NAME_REGEX_NOT_MATCH "^[Mm][Ii][Tt][Kk].*$")
 set(MITK_DEFAULT_MODULE_NAME_PREFIX "Mitk")
 set(MITK_MODULE_NAME_PREFIX ${MITK_DEFAULT_MODULE_NAME_PREFIX})
 set(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME 1)
 
 #-----------------------------------------------------------------------------
 # Get MITK version info
 #-----------------------------------------------------------------------------
 
 mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
 mitkFunctionGetVersionDescription(${MITK_SOURCE_DIR} MITK)
 
 # MITK_VERSION
 set(MITK_VERSION_STRING "${MITK_VERSION_MAJOR}.${MITK_VERSION_MINOR}.${MITK_VERSION_PATCH}")
 if(MITK_VERSION_PATCH STREQUAL "99")
   set(MITK_VERSION_STRING "${MITK_VERSION_STRING}-${MITK_REVISION_SHORTID}")
 endif()
 
 #-----------------------------------------------------------------------------
 # Installation preparation
 #
 # These should be set before any MITK install macros are used
 #-----------------------------------------------------------------------------
 
 # on macOS all BlueBerry plugins get copied into every
 # application bundle (.app directory) specified here
 if(MITK_USE_BLUEBERRY AND APPLE)
 
   foreach(MITK_EXTENSION_DIR ${MITK_DIR_PLUS_EXTENSION_DIRS})
     set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
     if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
       set(MITK_APPS "")
       include("${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
       foreach(mitk_app ${MITK_APPS})
         # extract option_name
         string(REPLACE "^^" "\\;" target_info ${mitk_app})
         set(target_info_list ${target_info})
         list(GET target_info_list 1 option_name)
         list(GET target_info_list 0 app_name)
         # check if the application is enabled
         if(${option_name} OR MITK_BUILD_ALL_APPS)
           set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} Mitk${app_name})
         endif()
       endforeach()
     endif()
   endforeach()
 
 endif()
 
 #-----------------------------------------------------------------------------
 # Set coverage Flags
 #-----------------------------------------------------------------------------
 
 if(WITH_COVERAGE)
   if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG")
     set(COVERAGE_CXX_FLAGS ${coverage_flags})
     set(COVERAGE_C_FLAGS ${coverage_flags})
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK C/CXX Flags
 #-----------------------------------------------------------------------------
 
 set(MITK_C_FLAGS "${COVERAGE_C_FLAGS}")
 set(MITK_C_FLAGS_DEBUG )
 set(MITK_C_FLAGS_RELEASE )
 set(MITK_CXX_FLAGS "${COVERAGE_CXX_FLAGS} ${MITK_CXX${MITK_CXX_STANDARD}_FLAG}")
 set(MITK_CXX_FLAGS_DEBUG )
 set(MITK_CXX_FLAGS_RELEASE )
 
 set(MITK_EXE_LINKER_FLAGS )
 set(MITK_SHARED_LINKER_FLAGS )
 
 if(WIN32)
   set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN -DNOMINMAX")
   mitkFunctionCheckCompilerFlags("/wd4005" MITK_CXX_FLAGS) # warning C4005: macro redefinition
   mitkFunctionCheckCompilerFlags("/wd4231" MITK_CXX_FLAGS) # warning C4231: nonstandard extension used : 'extern' before template explicit instantiation
   # the following line should be removed after fixing bug 17637
   mitkFunctionCheckCompilerFlags("/wd4316" MITK_CXX_FLAGS) # warning C4316: object alignment on heap
   mitkFunctionCheckCompilerFlags("/wd4180" MITK_CXX_FLAGS) # warning C4180: qualifier applied to function type has no meaning
   mitkFunctionCheckCompilerFlags("/wd4251" MITK_CXX_FLAGS) # warning C4251: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
 endif()
 
 if(APPLE)
   set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -DGL_SILENCE_DEPRECATION") # Apple deprecated OpenGL in macOS 10.14
 endif()
 
 if(NOT MSVC_VERSION)
   foreach(_flag
     -Wall
     -Wextra
     -Wpointer-arith
     -Winvalid-pch
     -Wcast-align
     -Wwrite-strings
     -Wno-error=gnu
     -Wno-error=unknown-pragmas
     # The strict-overflow warning is generated by ITK template code
     -Wno-error=strict-overflow
     -Woverloaded-virtual
     -Wstrict-null-sentinel
     #-Wold-style-cast
     #-Wsign-promo
     -Wno-deprecated-copy
     -Wno-array-bounds
     -Wno-cast-function-type
     -Wno-maybe-uninitialized
     -Wno-error=stringop-overread
     -fdiagnostics-show-option
     )
     mitkFunctionCheckCAndCXXCompilerFlags(${_flag} MITK_C_FLAGS MITK_CXX_FLAGS)
   endforeach()
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE)
   mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" MITK_SHARED_LINKER_FLAGS)
   mitkFunctionCheckCompilerFlags("-Wl,--as-needed" MITK_SHARED_LINKER_FLAGS)
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   mitkFunctionCheckCAndCXXCompilerFlags("-fstack-protector-all" MITK_C_FLAGS MITK_CXX_FLAGS)
   set(MITK_CXX_FLAGS_RELEASE "-U_FORTIFY_SOURCES -D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}")
 endif()
 
 set(MITK_MODULE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
 set(MITK_EXE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
 
 #-----------------------------------------------------------------------------
 # MITK Packages
 #-----------------------------------------------------------------------------
 
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   set(MITK_PACKAGE_DEPENDS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMake/PackageDepends")
   if(EXISTS "${MITK_PACKAGE_DEPENDS_EXTENSION_DIR}")
     list(APPEND MODULES_PACKAGE_DEPENDS_DIRS "${MITK_PACKAGE_DEPENDS_EXTENSION_DIR}")
   endif()
 endforeach()
 
 if(NOT MITK_USE_SYSTEM_Boost)
   set(Boost_NO_SYSTEM_PATHS 1)
 endif()
 
 set(Boost_USE_MULTITHREADED 1)
 set(Boost_USE_STATIC_LIBS 0)
 set(Boost_USE_STATIC_RUNTIME 0)
 set(Boost_ADDITIONAL_VERSIONS 1.74 1.74.0)
 
 # We need this later for a DCMTK workaround
 set(_dcmtk_dir_orig ${DCMTK_DIR})
 
 # This property is populated at the top half of this file
 get_property(MITK_EXTERNAL_PROJECTS GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS)
 foreach(ep ${MITK_EXTERNAL_PROJECTS})
   get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE)
   get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
   if(MITK_USE_${ep} AND _package)
     if(_components)
       find_package(${_package} COMPONENTS ${_components} REQUIRED CONFIG)
     else()
       # Prefer config mode first because it finds external
       # <proj>Config.cmake files pointed at by <proj>_DIR variables.
       # Otherwise, existing Find<proj>.cmake files could fail.
 
       if(DEFINED ${_package}_DIR)
         #we store the information because it will be overwritten by find_package
         #and would get lost for all EPs that use on Find<proj>.cmake instead of config
         #files.
         set(_temp_EP_${_package}_dir ${${_package}_DIR})
       endif(DEFINED ${_package}_DIR)
 
       find_package(${_package} QUIET CONFIG)
       string(TOUPPER "${_package}" _package_uc)
       if(NOT (${_package}_FOUND OR ${_package_uc}_FOUND))
         if(DEFINED _temp_EP_${_package}_dir)
             set(${_package}_DIR ${_temp_EP_${_package}_dir} CACHE PATH "externaly set dir of the package ${_package}" FORCE)
         endif(DEFINED _temp_EP_${_package}_dir)
 
         find_package(${_package} REQUIRED)
       endif()
     endif()
   endif()
 endforeach()
 
 # Ensure that the MITK CMake module path comes first
 set(CMAKE_MODULE_PATH
   ${MITK_CMAKE_DIR}
   ${CMAKE_MODULE_PATH}
   )
 
 if(MITK_USE_DCMTK)
   if(${_dcmtk_dir_orig} MATCHES "${MITK_EXTERNAL_PROJECT_PREFIX}.*")
     # Help our FindDCMTK.cmake script find our super-build DCMTK
     set(DCMTK_DIR ${MITK_EXTERNAL_PROJECT_PREFIX})
   else()
     # Use the original value
     set(DCMTK_DIR ${_dcmtk_dir_orig})
   endif()
 endif()
 
 if(MITK_USE_DCMQI)
   # Due to the preferred CONFIG mode in find_package calls above,
   # the DCMQIConfig.cmake file is read, which does not provide useful
   # package information. We explictly need MODULE mode to find DCMQI.
     # Help our FindDCMQI.cmake script find our super-build DCMQI
   set(DCMQI_DIR ${MITK_EXTERNAL_PROJECT_PREFIX})
   find_package(DCMQI REQUIRED)
 endif()
 
 if(MITK_USE_OpenIGTLink)
   link_directories(${OpenIGTLink_LIBRARY_DIRS})
 endif()
 
 if(MITK_USE_OpenCL)
   find_package(OpenCL REQUIRED)
 endif()
 
 if(MITK_USE_OpenMP)
   find_package(OpenMP REQUIRED COMPONENTS CXX)
 else()
   find_package(OpenMP QUIET COMPONENTS CXX)
 
   if(OpenMP_FOUND)
     set(MITK_USE_OpenMP ON CACHE BOOL "" FORCE)
   elseif(APPLE AND OpenMP_libomp_LIBRARY AND NOT OpenMP_CXX_LIB_NAMES)
     set(OpenMP_CXX_LIB_NAMES libomp CACHE STRING "" FORCE)
     get_filename_component(openmp_lib_dir "${OpenMP_libomp_LIBRARY}" DIRECTORY)
     set(openmp_include_dir "${openmp_lib_dir}/../include")
     if(EXISTS "${openmp_include_dir}")
       get_filename_component(openmp_include_dir "${openmp_include_dir}" REALPATH)
       set(OpenMP_CXX_FLAGS "-Xpreprocessor -fopenmp -I${openmp_include_dir}" CACHE STRING "" FORCE)
       find_package(OpenMP QUIET COMPONENTS CXX)
       if(OpenMP_FOUND)
         set(MITK_USE_OpenMP ON CACHE BOOL "" FORCE)
       endif()
     endif()
   endif()
 endif()
 
 # Qt support
 if(MITK_USE_Qt5)
   find_package(Qt5Core ${MITK_QT5_MINIMUM_VERSION} REQUIRED) # at least Core required
   get_target_property(_qmake_exec Qt5::qmake LOCATION)
   execute_process(COMMAND ${_qmake_exec} -query QT_INSTALL_BINS
     RESULT_VARIABLE _result
      OUTPUT_VARIABLE QT_BINARY_DIR
     ERROR_VARIABLE _error
   )
   string(STRIP "${QT_BINARY_DIR}" QT_BINARY_DIR)
   if(_result OR NOT EXISTS "${QT_BINARY_DIR}")
     message(FATAL_ERROR "Could not determine Qt binary directory: ${_result} ${QT_BINARY_DIR} ${_error}")
   endif()
 
   find_program(QT_HELPGENERATOR_EXECUTABLE
     NAMES qhelpgenerator qhelpgenerator-qt5 qhelpgenerator5
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   find_program(QT_COLLECTIONGENERATOR_EXECUTABLE
     NAMES qcollectiongenerator qcollectiongenerator-qt5 qcollectiongenerator5
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   find_program(QT_ASSISTANT_EXECUTABLE
     NAMES assistant assistant-qt5 assistant5
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   find_program(QT_XMLPATTERNS_EXECUTABLE
     NAMES xmlpatterns
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   mark_as_advanced(QT_HELPGENERATOR_EXECUTABLE
                    QT_COLLECTIONGENERATOR_EXECUTABLE
                    QT_ASSISTANT_EXECUTABLE
                    QT_XMLPATTERNS_EXECUTABLE
                   )
 
   if(MITK_USE_BLUEBERRY)
     option(BLUEBERRY_USE_QT_HELP "Enable support for integrating plugin documentation into Qt Help" ${DOXYGEN_FOUND})
     mark_as_advanced(BLUEBERRY_USE_QT_HELP)
 
     # Sanity checks for in-application BlueBerry plug-in help generation
     if(BLUEBERRY_USE_QT_HELP)
       set(_force_blueberry_use_qt_help_to_off 0)
       if(NOT DOXYGEN_FOUND)
         message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because Doxygen was not found.")
         set(_force_blueberry_use_qt_help_to_off 1)
       endif()
       if(DOXYGEN_FOUND AND DOXYGEN_VERSION VERSION_LESS 1.8.7)
         message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because Doxygen version 1.8.7 or newer not found.")
         set(_force_blueberry_use_qt_help_to_off 1)
       endif()
 
       if(NOT QT_HELPGENERATOR_EXECUTABLE)
         message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because QT_HELPGENERATOR_EXECUTABLE is empty.")
         set(_force_blueberry_use_qt_help_to_off 1)
       endif()
 
       if(NOT MITK_USE_Qt5)
         message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because MITK_USE_Qt5 is OFF.")
         set(_force_blueberry_use_qt_help_to_off 1)
       endif()
 
       if(NOT QT_XMLPATTERNS_EXECUTABLE)
         message("You have enabled Qt Help support, but QT_XMLPATTERNS_EXECUTABLE is empty")
         set(_force_blueberry_use_qt_help_to_off 1)
       endif()
 
       if(_force_blueberry_use_qt_help_to_off)
         set(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating plugin documentation into Qt Help" FORCE)
       endif()
     endif()
 
     if(BLUEBERRY_QT_HELP_REQUIRED AND NOT BLUEBERRY_USE_QT_HELP)
       message(FATAL_ERROR "BLUEBERRY_USE_QT_HELP is required to be set to ON")
     endif()
   endif()
 
 endif()
 
 #-----------------------------------------------------------------------------
 # Testing
 #-----------------------------------------------------------------------------
 
 if(BUILD_TESTING)
   #[[ See T27701
   # Initial cache for ProjectTemplate and PluginGenerator tests
   configure_file(
      CMake/mitkTestInitialCache.txt.in
      ${MITK_BINARY_DIR}/mitkTestInitialCache.txt
      @ONLY
   )]]
 
   # Configuration for the CMake-generated test driver
   set(CMAKE_TESTDRIVER_EXTRA_INCLUDES "#include <stdexcept>")
   set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "
     try
       {")
   set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "
       }
       catch (const std::exception& e)
       {
         fprintf(stderr, \"%s\\n\", e.what());
         return EXIT_FAILURE;
       }
       catch (...)
       {
         printf(\"Exception caught in the test driver\\n\");
         return EXIT_FAILURE;
       }")
 
   set(MITK_TEST_OUTPUT_DIR "${MITK_BINARY_DIR}/test_output")
   if(NOT EXISTS ${MITK_TEST_OUTPUT_DIR})
     file(MAKE_DIRECTORY ${MITK_TEST_OUTPUT_DIR})
   endif()
 
   # Test the package target
   include(mitkPackageTest)
 endif()
 
 configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h)
 
 #-----------------------------------------------------------------------------
 # MITK_SUPERBUILD_BINARY_DIR
 #-----------------------------------------------------------------------------
 
 # If MITK_SUPERBUILD_BINARY_DIR isn't defined, it means MITK is *NOT* build using Superbuild.
 # In that specific case, MITK_SUPERBUILD_BINARY_DIR should default to MITK_BINARY_DIR
 if(NOT DEFINED MITK_SUPERBUILD_BINARY_DIR)
   set(MITK_SUPERBUILD_BINARY_DIR ${MITK_BINARY_DIR})
 endif()
 
 #-----------------------------------------------------------------------------
 # Set C/CXX and linker flags for MITK code
 #-----------------------------------------------------------------------------
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${MITK_CXX_FLAGS_DEBUG}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MITK_CXX_FLAGS_RELEASE}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MITK_C_FLAGS}")
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${MITK_C_FLAGS_DEBUG}")
 set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${MITK_C_FLAGS_RELEASE}")
 
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MITK_EXE_LINKER_FLAGS}")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MITK_SHARED_LINKER_FLAGS}")
 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MITK_MODULE_LINKER_FLAGS}")
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Utilities)
 
 add_subdirectory(Modules)
 
 include("${CMAKE_CURRENT_SOURCE_DIR}/Modules/ModuleList.cmake")
 mitkFunctionWhitelistModules(MITK MITK_MODULES)
 
 set(MITK_ROOT_FOLDER_BACKUP "${MITK_ROOT_FOLDER}")
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   get_filename_component(MITK_ROOT_FOLDER "${MITK_EXTENSION_DIR}" NAME)
   set(MITK_MODULES_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Modules")
   if(EXISTS "${MITK_MODULES_EXTENSION_DIR}/ModuleList.cmake")
     set(MITK_MODULES "")
     include("${MITK_MODULES_EXTENSION_DIR}/ModuleList.cmake")
     foreach(mitk_module ${MITK_MODULES})
       add_subdirectory("${MITK_MODULES_EXTENSION_DIR}/${mitk_module}" "Modules/${mitk_module}")
     endforeach()
   endif()
   set(MITK_MODULE_NAME_PREFIX ${MITK_DEFAULT_MODULE_NAME_PREFIX})
 endforeach()
 set(MITK_ROOT_FOLDER "${MITK_ROOT_FOLDER_BACKUP}")
 
 add_subdirectory(Wrapping)
 
 set(MITK_DOXYGEN_OUTPUT_DIR "${PROJECT_BINARY_DIR}/Documentation/Doxygen" CACHE PATH
   "Output directory for doxygen generated documentation.")
 
 if(MITK_USE_BLUEBERRY)
   include("${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PluginList.cmake")
   mitkFunctionWhitelistPlugins(MITK MITK_PLUGINS)
 
   set(mitk_plugins_fullpath "")
   foreach(mitk_plugin ${MITK_PLUGINS})
     list(APPEND mitk_plugins_fullpath Plugins/${mitk_plugin})
   endforeach()
 
   set(MITK_PLUGIN_REGEX_LIST "")
   foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
     set(MITK_PLUGINS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Plugins")
     if(EXISTS "${MITK_PLUGINS_EXTENSION_DIR}/PluginList.cmake")
       set(MITK_PLUGINS "")
       include("${MITK_PLUGINS_EXTENSION_DIR}/PluginList.cmake")
       foreach(mitk_plugin ${MITK_PLUGINS})
         list(APPEND mitk_plugins_fullpath "${MITK_PLUGINS_EXTENSION_DIR}/${mitk_plugin}")
       endforeach()
     endif()
   endforeach()
 
   if(EXISTS ${MITK_PRIVATE_MODULES}/PluginList.cmake)
     include(${MITK_PRIVATE_MODULES}/PluginList.cmake)
 
     foreach(mitk_plugin ${MITK_PRIVATE_PLUGINS})
       list(APPEND mitk_plugins_fullpath ${MITK_PRIVATE_MODULES}/${mitk_plugin})
     endforeach()
   endif()
 
   if(MITK_BUILD_EXAMPLES)
     include("${CMAKE_CURRENT_SOURCE_DIR}/Examples/Plugins/PluginList.cmake")
     set(mitk_example_plugins_fullpath )
     foreach(mitk_example_plugin ${MITK_EXAMPLE_PLUGINS})
       list(APPEND mitk_example_plugins_fullpath Examples/Plugins/${mitk_example_plugin})
       list(APPEND mitk_plugins_fullpath Examples/Plugins/${mitk_example_plugin})
     endforeach()
   endif()
 
   # Specify which plug-ins belong to this project
   macro(GetMyTargetLibraries all_target_libraries varname)
     set(re_ctkplugin_mitk "^org_mitk_[a-zA-Z0-9_]+$")
     set(re_ctkplugin_bb "^org_blueberry_[a-zA-Z0-9_]+$")
     set(_tmp_list)
     list(APPEND _tmp_list ${all_target_libraries})
     ctkMacroListFilter(_tmp_list re_ctkplugin_mitk re_ctkplugin_bb MITK_PLUGIN_REGEX_LIST OUTPUT_VARIABLE ${varname})
   endmacro()
 
   # Get infos about application directories and build options
   set(mitk_apps_fullpath "")
   foreach(MITK_EXTENSION_DIR ${MITK_DIR_PLUS_EXTENSION_DIRS})
     set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
     if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
       set(MITK_APPS "")
       include("${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
       foreach(mitk_app ${MITK_APPS})
         # extract option_name
         string(REPLACE "^^" "\\;" target_info ${mitk_app})
         set(target_info_list ${target_info})
         list(GET target_info_list 0 directory_name)
         list(GET target_info_list 1 option_name)
         if(${option_name})
           list(APPEND mitk_apps_fullpath "${MITK_APPLICATIONS_EXTENSION_DIR}/${directory_name}^^${option_name}")
         endif()
       endforeach()
     endif()
   endforeach()
 
   if (mitk_plugins_fullpath)
     ctkMacroSetupPlugins(${mitk_plugins_fullpath}
                          BUILD_OPTION_PREFIX MITK_BUILD_
                          APPS ${mitk_apps_fullpath}
                          BUILD_ALL ${MITK_BUILD_ALL_PLUGINS}
                          COMPACT_OPTIONS)
   endif()
 
   set(MITK_PLUGIN_USE_FILE "${MITK_BINARY_DIR}/MitkPluginUseFile.cmake")
   if(${PROJECT_NAME}_PLUGIN_LIBRARIES)
     ctkFunctionGeneratePluginUseFile(${MITK_PLUGIN_USE_FILE})
   else()
     file(REMOVE ${MITK_PLUGIN_USE_FILE})
     set(MITK_PLUGIN_USE_FILE )
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 if(DOXYGEN_FOUND)
   add_subdirectory(Documentation)
 endif()
 
 #-----------------------------------------------------------------------------
 # Installation
 #-----------------------------------------------------------------------------
 
 
 # set MITK cpack variables
 # These are the default variables, which can be overwritten ( see below )
 include(mitkSetupCPack)
 
 set(use_default_config ON)
 
 set(ALL_MITK_APPS "")
 set(activated_apps_no 0)
 
 foreach(MITK_EXTENSION_DIR ${MITK_DIR_PLUS_EXTENSION_DIRS})
   set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
   if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
     set(MITK_APPS "")
     include("${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
     foreach(mitk_app ${MITK_APPS})
       string(REPLACE "^^" "\\;" target_info ${mitk_app})
       set(target_info_list ${target_info})
       list(GET target_info_list 0 directory_name)
       list(GET target_info_list 1 option_name)
       list(GET target_info_list 2 executable_name)
       list(APPEND ALL_MITK_APPS "${MITK_EXTENSION_DIR}/Applications/${directory_name}^^${option_name}^^${executable_name}")
       if(${option_name} OR MITK_BUILD_ALL_APPS)
         MATH(EXPR activated_apps_no "${activated_apps_no} + 1")
       endif()
     endforeach()
   endif()
 endforeach()
 
 list(LENGTH ALL_MITK_APPS app_count)
 
 if(app_count EQUAL 1 AND (activated_apps_no EQUAL 1 OR MITK_BUILD_ALL_APPS))
   # Corner case if there is only one app in total
   set(use_project_cpack ON)
 elseif(activated_apps_no EQUAL 1 AND NOT MITK_BUILD_ALL_APPS)
   # Only one app is enabled (no "build all" flag set)
   set(use_project_cpack ON)
 else()
   # Less or more then one app is enabled
   set(use_project_cpack OFF)
 endif()
 
 foreach(mitk_app ${ALL_MITK_APPS})
   # extract target_dir and option_name
   string(REPLACE "^^" "\\;" target_info ${mitk_app})
   set(target_info_list ${target_info})
   list(GET target_info_list 0 target_dir)
   list(GET target_info_list 1 option_name)
   list(GET target_info_list 2 executable_name)
   # check if the application is enabled
   if(${option_name} OR MITK_BUILD_ALL_APPS)
     # check whether application specific configuration files will be used
     if(use_project_cpack)
       # use files if they exist
       if(EXISTS "${target_dir}/CPackOptions.cmake")
         include("${target_dir}/CPackOptions.cmake")
       endif()
 
       if(EXISTS "${target_dir}/CPackConfig.cmake.in")
         set(CPACK_PROJECT_CONFIG_FILE "${target_dir}/CPackConfig.cmake")
         configure_file(${target_dir}/CPackConfig.cmake.in
                        ${CPACK_PROJECT_CONFIG_FILE} @ONLY)
         set(use_default_config OFF)
       endif()
     endif()
   # add link to the list
   list(APPEND CPACK_CREATE_DESKTOP_LINKS "${executable_name}")
   endif()
 endforeach()
 
 # if no application specific configuration file was used, use default
 if(use_default_config)
   configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
                  ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY)
   set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake")
 endif()
 
 # include CPack model once all variables are set
 include(CPack)
 
 # Additional installation rules
 include(mitkInstallRules)
 
 #-----------------------------------------------------------------------------
 # Last configuration steps
 #-----------------------------------------------------------------------------
 
 # ---------------- Export targets -----------------
 
 set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake")
 file(REMOVE ${MITK_EXPORTS_FILE})
 
 set(targets_to_export)
 get_property(module_targets GLOBAL PROPERTY MITK_MODULE_TARGETS)
 if(module_targets)
   list(APPEND targets_to_export ${module_targets})
 endif()
 
 if(MITK_USE_BLUEBERRY)
   if(MITK_PLUGIN_LIBRARIES)
     list(APPEND targets_to_export ${MITK_PLUGIN_LIBRARIES})
   endif()
 endif()
 
 export(TARGETS ${targets_to_export} APPEND
        FILE ${MITK_EXPORTS_FILE})
 
 set(MITK_EXPORTED_TARGET_PROPERTIES )
 foreach(target_to_export ${targets_to_export})
   get_target_property(autoload_targets ${target_to_export} MITK_AUTOLOAD_TARGETS)
   if(autoload_targets)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_TARGETS \"${autoload_targets}\")")
   endif()
   get_target_property(autoload_dir ${target_to_export} MITK_AUTOLOAD_DIRECTORY)
   if(autoload_dir)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_DIRECTORY \"${autoload_dir}\")")
   endif()
 
   get_target_property(deprecated_module ${target_to_export} MITK_MODULE_DEPRECATED_SINCE)
   if(deprecated_module)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_MODULE_DEPRECATED_SINCE \"${deprecated_module}\")")
   endif()
 endforeach()
 
 # ---------------- External projects -----------------
 
 get_property(MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS_CONFIG GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
 
 set(MITK_CONFIG_EXTERNAL_PROJECTS )
 #string(REPLACE "^^" ";" _mitk_external_projects ${MITK_EXTERNAL_PROJECTS})
 
 foreach(ep ${MITK_EXTERNAL_PROJECTS})
   get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
   set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS}
 set(MITK_USE_${ep} ${MITK_USE_${ep}})
 set(MITK_${ep}_DIR \"${${ep}_DIR}\")
 set(MITK_${ep}_COMPONENTS ${_components})
 ")
 endforeach()
 
 foreach(ep ${MITK_EXTERNAL_PROJECTS})
   get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE)
   get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
   if(_components)
       set(_components_arg COMPONENTS \${_components})
   else()
     set(_components_arg)
   endif()
 
   if(_package)
     set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS}
 if(MITK_USE_${ep})
   set(${ep}_DIR \${MITK_${ep}_DIR})
   if(MITK_${ep}_COMPONENTS)
     mitkMacroFindDependency(${_package} COMPONENTS \${MITK_${ep}_COMPONENTS})
   else()
     mitkMacroFindDependency(${_package})
   endif()
 endif()")
   endif()
 endforeach()
 
 
 # ---------------- Tools -----------------
 
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY)
 
 # ---------------- Configure files -----------------
 
 configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h)
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 
 set(IPFUNC_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipFunc)
 set(UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities)
 
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY)
 
 write_basic_config_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
   VERSION ${MITK_VERSION_STRING} COMPATIBILITY AnyNewerVersion)
 
 #-----------------------------------------------------------------------------
 # MITK Applications
 #-----------------------------------------------------------------------------
 
 # This must come after MITKConfig.h was generated, since applications
 # might do a find_package(MITK REQUIRED).
 add_subdirectory(Applications)
 
 if(MSVC AND TARGET MitkWorkbench)
   set_directory_properties(PROPERTIES VS_STARTUP_PROJECT MitkWorkbench)
 endif()
 
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
   if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/CMakeLists.txt")
     add_subdirectory("${MITK_APPLICATIONS_EXTENSION_DIR}" "Applications")
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # MITK Examples
 #-----------------------------------------------------------------------------
 
 if(MITK_BUILD_EXAMPLES)
   # This must come after MITKConfig.h was generated, since applications
   # might do a find_package(MITK REQUIRED).
   add_subdirectory(Examples)
 endif()
 
 #-----------------------------------------------------------------------------
 # Print configuration summary
 #-----------------------------------------------------------------------------
 
 message("\n\n")
 feature_summary(
   DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------"
   WHAT ALL
 )
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step04.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step04.dox
index e399106c64..a2f3cffb0b 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step04.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step04.dox
@@ -1,67 +1,67 @@
 /**
 
 \page Step04Page MITK Tutorial - Step 4: Use several views to explore data
 
 \li Examples/Tutorial/Step4
 \li https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image) \n
 https://www.mitk.org/download/tutorial-data/lungs.vtk (surface)
 
 As in Step 2 and Step 3 one or more data sets may be loaded.
 
 This now creates three views on the data.
 The QmitkRenderWindow is used for displaying a 3D view as in Step 3, but without volume-rendering.
 Furthermore two 2D views for slicing through the data are created.
 The class QmitkSliceWidget is used, which is based on the class QmitkRenderWindow, but additionally provides sliders to slice through the data. We create two instances of
 QmitkSliceWidget, one for axial and one for sagittal slicing.
 Step 4b enhances the program in that the two slices are also shown at their correct position in 3D as well as intersection-line, each in the other 2D view.
 
 As in the previous steps, to obtain the result the program has to be executed using the image file Pic3D.nrrd and the surface file lungs.vtk.
 
 \section Step4aSection Step 4a - Create axial and sagittal view
 
 \imageMacro{step4a_result.png,"",11.01}
 
 \dontinclude Step4.cpp
 
 Create a Qt horizontal box for the layout:
 
 \skipline QHBox
 
 Then create a renderwindow:
 
 \skipline QmitkRenderWindow
 \until SetMapperID
 
 Create a 2D view for slicing axially:
 
 \skipline view2
 \until view2.SetData
 
-Then create a 2D view for slicing sagitally.
+Then create a 2D view for slicing sagittally.
 
 \skipline view3
 \until view3.SetData
 
 The toplevelWidget is now the new main widget:
 
 \skipline qtapplication
 \skipline toplevelWidget.show
 
 \section Step4bSection Step 4b - Display slice positions
 
 \imageMacro{step4b_result.png,"",11.01}
 
 We now want to see the position of the slice in 2D and the slice itself in 3D.
 Therefore it has to be added to the tree:
 
 \dontinclude Step4.cpp
 \skipline ds->Add(view2.GetRenderer()
 \skipline ds->Add(view3.GetRenderer()
 
 Slice positions are now displayed as shown in the picture.
 
 \dontinclude Step4.cpp
 
 \ref Step03Page "[Previous step]" \ref Step05Page "[Next step]" \ref TutorialPage "[Main tutorial page]"
 
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox
index 5d760fedaa..c9d1bd489a 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox
@@ -1,111 +1,115 @@
 /**
 \page thirdpartylibs Third-party libraries
 
 The following third-party libraries can be used with MITK by default and can, in part, be automatically downloaded during superbuild.
 
 \par ANN
 
 https://www.cs.umd.edu/~mount/ANN/
 
 \par Boost
 
 https://www.boost.org/
 
 \par C++ REST SDK
 
 https://github.com/Microsoft/cpprestsdk/
 
 \par CppUnit
 
 https://sourceforge.net/projects/cppunit/
 
 \par CTK
 
 https://commontk.org/
 
 \par DCMTK
 
 https://dicom.offis.de/dcmtk
 
 \par Eigen
 
 http://eigen.tuxfamily.org/index.php?title=Main_Page
 
 \par GDCM
 
 https://gdcm.sourceforge.net/
 
 \par HDF5
 
 https://support.hdfgroup.org/HDF5/
 
 \par ITK
 
 https://itk.org/
 
+\par JSON for Modern C++
+
+https://github.com/nlohmann/json
+
 \par lz4
 
 https://github.com/lz4/lz4
 
 \par MatchPoint
 
 https://www.dkfz.de/en/sidt/projects/MatchPoint/info.html
 
 \par OpenCL
 
 https://www.khronos.org/opencl/
 
 \par OpenCV
 
 https://opencv.org/
 
 \par OpenIGTLink
 
 http://openigtlink.org/
 
 \par OpenMesh
 
 https://www.openmesh.org/
 
 \par PCRE
 
 https://www.pcre.org/
 
 \par POCO
 
 https://pocoproject.org/
 
 \par Python
 
 https://www.python.org/
 
 \par Qt
 
 https://www.qt.io/
 
 \par Qwt
 
 http://qwt.sourceforge.net/
 
 \par SWIG
 
 http://www.swig.org/
 
 \par TinyXML-2
 
 http://www.grinninglizard.com/tinyxml2/
 
 \par VIGRA
 
 https://ukoethe.github.io/vigra/
 
 \par VTK
 
 https://vtk.org/
 
 \par zlib
 
 https://zlib.net/
 
 For copyright information on any of the above toolkits see the corresponding home page or the corresponding source folder.
 */
diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
index f51bbb69e1..d503701503 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
@@ -1,202 +1,202 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "SimpleRenderWindowView.h"
 
 #include <QmitkRenderWindow.h>
 
 #include "org_mitk_example_gui_customviewer_views_Activator.h"
 #include <berryIBerryPreferences.h>
 #include <ctkServiceTracker.h>
 #include <mitkIRenderingManager.h>
 #include <mitkInteractionConst.h>
 #include <mitkSliceNavigationController.h>
 
 #include <QVBoxLayout>
 #include <mitkPlaneGeometry.h>
 
 /**
  * \brief Helper class adapted from QmitkAbstractRenderEditor by defining the correct plugin context.
  *
  *  This helper class adapted from QmitkAbstractRenderEditor provides the rendering manager interface.
  */
 // //! [SimpleRenderWindowViewHelper]
 class AbstractRenderWindowViewPrivate
 {
 public:
   AbstractRenderWindowViewPrivate()
     : m_RenderingManagerInterface(mitk::MakeRenderingManagerInterface(mitk::RenderingManager::GetInstance())),
       m_PrefServiceTracker(org_mitk_example_gui_customviewer_views_Activator::GetPluginContext())
   // //! [SimpleRenderWindowViewHelper]
   {
     m_PrefServiceTracker.open();
   }
 
   ~AbstractRenderWindowViewPrivate() { delete m_RenderingManagerInterface; }
   mitk::IRenderingManager *m_RenderingManagerInterface;
   ctkServiceTracker<berry::IPreferencesService *> m_PrefServiceTracker;
   berry::IBerryPreferences::Pointer m_Prefs;
 };
 
 const std::string SimpleRenderWindowView::VIEW_ID = "org.mitk.customviewer.views.simplerenderwindowview";
 
 SimpleRenderWindowView::SimpleRenderWindowView() : m_RenderWindow(nullptr), d(new AbstractRenderWindowViewPrivate)
 {
 }
 
 SimpleRenderWindowView::~SimpleRenderWindowView()
 {
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetActiveQmitkRenderWindow() const
 {
   return m_RenderWindow;
 }
 
 QHash<QString, QmitkRenderWindow *> SimpleRenderWindowView::GetRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow *> wnds;
-  wnds.insert("transversal", m_RenderWindow);
+  wnds.insert("axial", m_RenderWindow);
   return wnds;
 }
 
 QHash<QString, QmitkRenderWindow *> SimpleRenderWindowView::GetQmitkRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow *> wnds;
-  wnds.insert("transversal", m_RenderWindow);
+  wnds.insert("axial", m_RenderWindow);
   return wnds;
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetRenderWindow(const QString &id) const
 {
-  if (id == "transversal")
+  if (id == "axial")
   {
     return m_RenderWindow;
   }
   return nullptr;
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetQmitkRenderWindow(const QString &id) const
 {
-  if (id == "transversal")
+  if (id == "axial")
   {
     return m_RenderWindow;
   }
   return nullptr;
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection &viewDirection) const
 {
   if (viewDirection == mitk::BaseRenderer::ViewDirection::AXIAL)
   {
     return m_RenderWindow;
   }
   return 0;
 }
 
 void SimpleRenderWindowView::SetFocus()
 {
   m_RenderWindow->setFocus();
 }
 
 // //! [SimpleRenderWindowViewCreatePartControl]
 void SimpleRenderWindowView::CreateQtPartControl(QWidget *parent)
 {
   QVBoxLayout *layout = new QVBoxLayout(parent);
   layout->setContentsMargins(0, 0, 0, 0);
 
   m_RenderWindow = new QmitkRenderWindow(parent);
   layout->addWidget(m_RenderWindow);
 
   mitk::DataStorage::Pointer ds = this->GetDataStorage();
   m_RenderWindow->GetRenderer()->SetDataStorage(ds);
 
   this->RequestUpdate();
 }
 // //! [SimpleRenderWindowViewCreatePartControl]
 
 mitk::IRenderingManager *SimpleRenderWindowView::GetRenderingManager() const
 {
   // we use the global rendering manager here. This should maybe replaced
   // by a local one, managing only the render windows specific for the view
   return d->m_RenderingManagerInterface;
 }
 
 void SimpleRenderWindowView::RequestUpdate(mitk::RenderingManager::RequestType requestType)
 {
   if (GetRenderingManager())
     GetRenderingManager()->RequestUpdateAll(requestType);
 }
 
 void SimpleRenderWindowView::ForceImmediateUpdate(mitk::RenderingManager::RequestType requestType)
 {
   if (GetRenderingManager())
     GetRenderingManager()->ForceImmediateUpdateAll(requestType);
 }
 
 mitk::SliceNavigationController *SimpleRenderWindowView::GetTimeNavigationController() const
 {
   if (GetRenderingManager())
     return GetRenderingManager()->GetTimeNavigationController();
   return nullptr;
 }
 
 mitk::Point3D SimpleRenderWindowView::GetSelectedPosition(const QString& /*id*/) const
 {
   const mitk::PlaneGeometry* pg = m_RenderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   if (pg)
   {
     return pg->GetCenter();
   }
   else
   {
     return mitk::Point3D();
   }
 }
 
 void SimpleRenderWindowView::SetSelectedPosition(const mitk::Point3D&, const QString&)
 {
 }
 
 mitk::TimePointType SimpleRenderWindowView::GetSelectedTimePoint(const QString& /*id*/) const
 {
   auto timeNavigator = this->GetTimeNavigationController();
   if (nullptr != timeNavigator)
   {
     return timeNavigator->GetSelectedTimePoint();
   }
   return 0;
 }
 
 void SimpleRenderWindowView::EnableDecorations(bool enable, const QStringList& decorations)
 {
   if (decorations.isEmpty() || decorations.contains(DECORATION_MENU))
   {
     m_RenderWindow->ActivateMenuWidget(enable);
   }
 }
 
 bool SimpleRenderWindowView::IsDecorationEnabled(const QString& decoration) const
 {
   if (decoration == DECORATION_MENU)
   {
     return m_RenderWindow->GetActivateMenuWidgetFlag();
   }
   return false;
 }
 
 QStringList SimpleRenderWindowView::GetDecorations() const
 {
   QStringList decorations;
   decorations << DECORATION_MENU;
   return decorations;
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/colourimageprocessing/QmitkColourImageProcessingView.cpp b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/colourimageprocessing/QmitkColourImageProcessingView.cpp
index 3e1fdcaa98..641ddd8869 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/colourimageprocessing/QmitkColourImageProcessingView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/colourimageprocessing/QmitkColourImageProcessingView.cpp
@@ -1,264 +1,270 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkColourImageProcessingView.h"
 
 #include "ui_QmitkColourImageProcessingViewControls.h"
 
 #include "mitkColourImageProcessor.h"
 #include "mitkDataNodeObject.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 
 #include "QmitkColorTransferFunctionCanvas.h"
 #include "QmitkPiecewiseFunctionCanvas.h"
 
 #include <berryISelectionProvider.h>
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 #include <QColor>
 #include <QColorDialog>
 #include <QComboBox>
 #include <QMessageBox>
 
 const std::string QmitkColourImageProcessingView::VIEW_ID = "org.mitk.views.colourimageprocessing";
 
 QmitkColourImageProcessingView::QmitkColourImageProcessingView() : m_Controls(nullptr)
 {
   m_Color[0] = 255;
   m_Color[1] = 0;
   m_Color[2] = 0;
 }
 
 void QmitkColourImageProcessingView::SetFocus()
 {
   m_Controls->m_ConvertImageToRGBA->setFocus();
 }
 
 void QmitkColourImageProcessingView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     m_Controls = new Ui::QmitkColourImageProcessingViewControls;
     m_Controls->setupUi(parent);
 
     connect(m_Controls->m_ConvertImageToRGBA, SIGNAL(clicked(bool)), this, SLOT(OnConvertToRGBAImage()));
     connect(m_Controls->m_ConvertImageMaskToRGBA, SIGNAL(clicked(bool)), this, SLOT(OnConvertToRGBAImage()));
     connect(m_Controls->m_ConvertImageMaskColorToRGBA,
             SIGNAL(clicked(bool)),
             this,
             SLOT(OnConvertImageMaskColorToRGBAImage()));
     connect(m_Controls->m_ColorButton, SIGNAL(clicked(bool)), this, SLOT(OnChangeColor()));
     connect(m_Controls->m_CombineRGBAButton, SIGNAL(clicked(bool)), this, SLOT(OnCombineRGBA()));
 
     m_Controls->m_ImageSelectedLabel->hide();
     m_Controls->m_NoImageSelectedLabel->show();
   }
 }
 
 void QmitkColourImageProcessingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
                                                         const QList<mitk::DataNode::Pointer> &nodes)
 {
   if (!nodes.isEmpty())
   {
     QList<mitk::DataNode::Pointer> selectedNodes;
 
     foreach (const mitk::DataNode::Pointer node, nodes)
     {
       if (node.IsNotNull())
       {
         mitk::Image *image = dynamic_cast<mitk::Image *>(node->GetData());
         if(nullptr != image)
         {
           if (image->GetDimension() >= 3)
           {
             selectedNodes.push_back(node);
           }
         }
       }
     }
 
     mitk::DataNode::Pointer node;
 
     if (selectedNodes.size() > 0)
     {
       node = selectedNodes[0];
 
       m_SelectedNode = node;
 
       m_Controls->m_NoImageSelectedLabel->hide();
       m_Controls->m_ImageSelectedLabel->show();
 
       std::string infoText = std::string("Selected Image: ") + node->GetName();
 
       if (selectedNodes.size() > 1)
       {
         mitk::DataNode::Pointer node2;
         node2 = selectedNodes[1];
         m_SelectedNode2 = node2;
         infoText = infoText + " and " + node2->GetName();
       }
       else
       {
         m_SelectedNode2 = nullptr;
       }
       m_Controls->m_ImageSelectedLabel->setText(QString(infoText.c_str()));
     }
     else
     {
       m_Controls->m_ImageSelectedLabel->hide();
       m_Controls->m_NoImageSelectedLabel->show();
 
       m_SelectedNode = nullptr;
       m_SelectedNode2 = nullptr;
     }
   }
 }
 
 void QmitkColourImageProcessingView::OnConvertToRGBAImage()
 {
-  if (m_SelectedNode.IsExpired())
-    return;
-
   auto selectedNode = m_SelectedNode.Lock();
 
+  if (selectedNode.IsNull())
+    return;
+
   mitk::TransferFunctionProperty::Pointer transferFunctionProp =
     dynamic_cast<mitk::TransferFunctionProperty *>(selectedNode->GetProperty("TransferFunction"));
 
   if (transferFunctionProp.IsNull())
     return;
 
   mitk::TransferFunction::Pointer tf = transferFunctionProp->GetValue();
 
   if (tf.IsNull())
     return;
 
   mitk::mitkColourImageProcessor CImageProcessor;
 
   mitk::Image::Pointer RGBAImageResult;
+  auto selectedNode2 = m_SelectedNode2.Lock();
 
-  if (!m_SelectedNode2.IsExpired())
+  if (selectedNode2.IsNotNull())
   {
     RGBAImageResult =
       CImageProcessor.convertWithBinaryToRGBAImage(dynamic_cast<mitk::Image *>(selectedNode->GetData()),
-                                                   dynamic_cast<mitk::Image *>(m_SelectedNode2.Lock()->GetData()),
+                                                   dynamic_cast<mitk::Image *>(selectedNode2->GetData()),
                                                    tf);
   }
   else
   {
     RGBAImageResult = CImageProcessor.convertToRGBAImage(dynamic_cast<mitk::Image *>(selectedNode->GetData()), tf);
   }
 
   if (!RGBAImageResult)
   {
     QMessageBox::warning(nullptr, "Warning", QString("Unsupported pixeltype"));
     return;
   }
 
   mitk::DataNode::Pointer dtn = mitk::DataNode::New();
 
   dtn->SetData(RGBAImageResult);
   dtn->SetName(selectedNode->GetName() + "_RGBA");
   this->GetDataStorage()->Add(dtn); // add as a child, because the segmentation "derives" from the original
 
   MITK_INFO << "convertToRGBAImage finish";
 }
 
 void QmitkColourImageProcessingView::OnConvertImageMaskColorToRGBAImage()
 {
-  if (m_SelectedNode.IsExpired())
-    return;
-
   auto selectedNode = m_SelectedNode.Lock();
 
+  if (selectedNode.IsNull())
+    return;
+
   mitk::TransferFunctionProperty::Pointer transferFunctionProp =
     dynamic_cast<mitk::TransferFunctionProperty *>(selectedNode->GetProperty("TransferFunction"));
 
   if (transferFunctionProp.IsNull())
     return;
 
   mitk::TransferFunction::Pointer tf = transferFunctionProp->GetValue();
 
   if (tf.IsNull())
     return;
 
   mitk::mitkColourImageProcessor CImageProcessor;
 
   mitk::Image::Pointer RGBAImageResult;
+  auto selectedNode2 = m_SelectedNode2.Lock();
 
-  if (!m_SelectedNode2.IsExpired())
+  if (selectedNode2.IsNotNull())
   {
     RGBAImageResult =
       CImageProcessor.convertWithBinaryAndColorToRGBAImage(dynamic_cast<mitk::Image *>(selectedNode->GetData()),
-                                                           dynamic_cast<mitk::Image *>(m_SelectedNode2.Lock()->GetData()),
+                                                           dynamic_cast<mitk::Image *>(selectedNode2->GetData()),
                                                            tf,
                                                            m_Color);
   }
   else
   {
     RGBAImageResult = CImageProcessor.convertToRGBAImage(dynamic_cast<mitk::Image *>(selectedNode->GetData()), tf);
   }
 
   if (!RGBAImageResult)
   {
     QMessageBox::warning(nullptr, "Warning", QString("Unsupported pixeltype"));
     return;
   }
 
   mitk::DataNode::Pointer dtn = mitk::DataNode::New();
 
   dtn->SetData(RGBAImageResult);
   dtn->SetName(selectedNode->GetName() + "_RGBA");
 
   this->GetDataStorage()->Add(dtn); // add as a child, because the segmentation "derives" from the original
 }
 
 void QmitkColourImageProcessingView::OnChangeColor()
 {
   QColor color = QColorDialog::getColor();
   if (color.spec() == 0)
   {
     color.setRed(255);
     color.setGreen(0);
     color.setBlue(0);
   }
 
   m_Color[0] = color.red();
   m_Color[1] = color.green();
   m_Color[2] = color.blue();
 
   m_Controls->m_ColorButton->setStyleSheet(
     QString("background-color:rgb(%1,%2, %3)").arg(color.red()).arg(color.green()).arg(color.blue()));
 }
 
 void QmitkColourImageProcessingView::OnCombineRGBA()
 {
-  if (m_SelectedNode.IsExpired())
+  auto selectedNode = m_SelectedNode.Lock();
+
+  if (selectedNode.IsNull())
     return;
 
-  if (m_SelectedNode2.IsExpired())
+  auto selectedNode2 = m_SelectedNode2.Lock();
+
+  if (selectedNode2.IsNull())
     return;
 
   mitk::mitkColourImageProcessor CImageProcessor;
 
   mitk::Image::Pointer RGBAImageResult;
 
-  RGBAImageResult = CImageProcessor.combineRGBAImage(dynamic_cast<mitk::Image *>(m_SelectedNode.Lock()->GetData()),
-                                                     dynamic_cast<mitk::Image *>(m_SelectedNode2.Lock()->GetData()));
+  RGBAImageResult = CImageProcessor.combineRGBAImage(dynamic_cast<mitk::Image *>(selectedNode->GetData()),
+                                                     dynamic_cast<mitk::Image *>(selectedNode2->GetData()));
   MITK_INFO << "RGBAImage Result";
   mitk::DataNode::Pointer dtn = mitk::DataNode::New();
 
   dtn->SetData(RGBAImageResult);
 
   this->GetDataStorage()->Add(dtn); // add as a child, because the segmentation "derives" from the original
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/isosurface/QmitkIsoSurface.cpp b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/isosurface/QmitkIsoSurface.cpp
index 2935ce2e5d..692bee7b14 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/isosurface/QmitkIsoSurface.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/isosurface/QmitkIsoSurface.cpp
@@ -1,164 +1,163 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkIsoSurface.h"
 
 // MITK headers
 #include <mitkManualSegmentationToSurfaceFilter.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkSurface.h>
 
 // Qmitk headers
 #include <QmitkSelectableGLWidget.h>
-#include <QmitkStdMultiWidget.h>
 
 // Qt-GUI headers
 #include <QApplication>
 #include <QCursor>
 #include <QMessageBox>
 
 QmitkIsoSurface::QmitkIsoSurface(QObject * /*parent*/, const char * /*name*/)
   : m_Controls(nullptr), m_MitkImage(nullptr), m_SurfaceCounter(0)
 {
 }
 
 void QmitkIsoSurface::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     m_Controls = new Ui::QmitkIsoSurfaceControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_ImageSelector->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ImageSelector->SetPredicate(mitk::NodePredicateDataType::New("Image"));
 
     berry::IPreferences::Pointer prefs = this->GetPreferences();
     if (prefs.IsNotNull())
       m_Controls->thresholdLineEdit->setText(prefs->Get("defaultThreshold", "0"));
   }
 }
 
 void QmitkIsoSurface::SetFocus()
 {
   m_Controls->m_ImageSelector->setFocus();
 }
 
 void QmitkIsoSurface::CreateConnections()
 {
   if (m_Controls)
   {
     connect(m_Controls->m_ImageSelector,
             SIGNAL(OnSelectionChanged(const mitk::DataNode *)),
             this,
             SLOT(ImageSelected(const mitk::DataNode *)));
     connect(m_Controls->createSurfacePushButton, SIGNAL(clicked()), this, SLOT(CreateSurface()));
   }
 }
 
 void QmitkIsoSurface::ImageSelected(const mitk::DataNode *item)
 {
   // nothing selected (nullptr selection)
   if (item == nullptr || item->GetData() == nullptr)
     return;
 
   m_MitkImage = dynamic_cast<mitk::Image *>(item->GetData());
 }
 
 void QmitkIsoSurface::CreateSurface()
 {
   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
   if (m_MitkImage != nullptr)
   {
     // Value Gauss
     // float gsDev = 1.5;
 
     // Value for DecimatePro
     float targetReduction = 0.05;
 
     // ImageToSurface Instance
     mitk::DataNode::Pointer node = m_Controls->m_ImageSelector->GetSelectedNode();
 
     mitk::ManualSegmentationToSurfaceFilter::Pointer filter = mitk::ManualSegmentationToSurfaceFilter::New();
     if (filter.IsNull())
     {
       std::cout << "nullptr Pointer for ManualSegmentationToSurfaceFilter" << std::endl;
       return;
     }
 
     filter->SetInput(m_MitkImage);
     filter->SetGaussianStandardDeviation(0.5);
     filter->SetUseGaussianImageSmooth(true);
     filter->SetThreshold(getThreshold()); // if( Gauss ) --> TH manipulated for vtkMarchingCube
 
     filter->SetTargetReduction(targetReduction);
 
     int numOfPolys = filter->GetOutput()->GetVtkPolyData()->GetNumberOfPolys();
     if (numOfPolys > 2000000)
     {
       QApplication::restoreOverrideCursor();
       if (QMessageBox::question(nullptr,
                                 "CAUTION!!!",
                                 "The number of polygons is greater than 2 000 000. If you continue, the program might "
                                 "crash. How do you want to go on?",
                                 "Proceed anyway!",
                                 "Cancel immediately! (maybe you want to insert an other threshold)!",
                                 QString::null,
                                 0,
                                 1) == 1)
       {
         return;
       }
       QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
     }
     mitk::DataNode::Pointer surfaceNode = mitk::DataNode::New();
     surfaceNode->SetData(filter->GetOutput());
 
     int layer = 0;
 
     ++m_SurfaceCounter;
     std::ostringstream buffer;
     buffer << m_SurfaceCounter;
     std::string surfaceNodeName = "Surface " + buffer.str();
 
     node->GetIntProperty("layer", layer);
     surfaceNode->SetIntProperty("layer", layer + 1);
     surfaceNode->SetProperty("Surface", mitk::BoolProperty::New(true));
     surfaceNode->SetProperty("name", mitk::StringProperty::New(surfaceNodeName));
 
     this->GetDataStorage()->Add(surfaceNode, node);
 
     // to show surfaceContur
     surfaceNode->SetColor(m_RainbowColor.GetNextColor());
     surfaceNode->SetVisibility(true);
 
     mitk::IRenderWindowPart *renderPart = this->GetRenderWindowPart();
     if (renderPart)
     {
       renderPart->RequestUpdate();
     }
   }
 
   QApplication::restoreOverrideCursor();
 }
 
 float QmitkIsoSurface::getThreshold()
 {
   return m_Controls->thresholdLineEdit->text().toFloat();
 }
 
 QmitkIsoSurface::~QmitkIsoSurface()
 {
   berry::IPreferences::Pointer prefs = this->GetPreferences();
   if (prefs.IsNotNull())
     prefs->Put("defaultThreshold", m_Controls->thresholdLineEdit->text());
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/viewinitialization/QmitkViewInitializationView.cpp b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/viewinitialization/QmitkViewInitializationView.cpp
index ee9f42a7e6..1064857291 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/viewinitialization/QmitkViewInitializationView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/viewinitialization/QmitkViewInitializationView.cpp
@@ -1,169 +1,169 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkViewInitializationView.h"
 
 #include "mitkNodePredicateDataType.h"
 
 #include "QmitkDataStorageComboBox.h"
 #include "mitkCameraController.h"
 #include <mitkBaseRenderer.h>
 #include <mitkSliceNavigationController.h>
 
 #include "itkCommand.h"
 
 #include <QMessageBox>
 
 const std::string QmitkViewInitializationView::VIEW_ID = "org.mitk.views.viewinitialization";
 
 QmitkViewInitializationView::QmitkViewInitializationView() : m_Controls(nullptr)
 {
   m_CommandTag = 0;
 }
 
 QmitkViewInitializationView::~QmitkViewInitializationView()
 {
 }
 
 void QmitkViewInitializationView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkViewInitializationViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 }
 
 void QmitkViewInitializationView::SetFocus()
 {
   m_Controls->pbApply->setFocus();
 }
 
 void QmitkViewInitializationView::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject *)(m_Controls->pbApply), SIGNAL(clicked()), (QObject *)this, SLOT(OnApply()));
     connect((QObject *)(m_Controls->pbReset), SIGNAL(clicked()), (QObject *)this, SLOT(OnResetAll()));
   }
 }
 
 void QmitkViewInitializationView::Activated()
 {
   // init render window selector (List Widget)
   this->InitRenderWindowSelector();
 }
 
 void QmitkViewInitializationView::Deactivated()
 {
 }
 
 void QmitkViewInitializationView::Visible()
 {
 }
 
 void QmitkViewInitializationView::Hidden()
 {
 }
 
 void QmitkViewInitializationView::OnApply()
 {
   mitk::SliceNavigationController::ViewDirection viewDirection(mitk::SliceNavigationController::Axial);
   if (m_Controls->rbAxial->isChecked())
     viewDirection = mitk::SliceNavigationController::Axial;
 
-  else if (m_Controls->rbFrontal->isChecked())
-    viewDirection = mitk::SliceNavigationController::Frontal;
+  else if (m_Controls->rbCoronal->isChecked())
+    viewDirection = mitk::SliceNavigationController::Coronal;
 
   else if (m_Controls->rbSagittal->isChecked())
     viewDirection = mitk::SliceNavigationController::Sagittal;
 
   vtkRenderWindow *renderwindow = this->GetSelectedRenderWindow();
   if (renderwindow != nullptr)
   {
     mitk::BaseRenderer::GetInstance(renderwindow)
       ->GetSliceNavigationController()
       ->Update(viewDirection,
                m_Controls->cbTop->isChecked(),
                m_Controls->cbFrontSide->isChecked(),
                m_Controls->cbRotated->isChecked());
     mitk::BaseRenderer::GetInstance(renderwindow)->GetCameraController()->Fit();
   }
 }
 
 void QmitkViewInitializationView::OnResetAll()
 {
   /* calculate bounding geometry of these nodes */
   auto bounds = this->GetDataStorage()->ComputeBoundingGeometry3D();
   /* initialize the views to the bounding geometry */
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 }
 
 vtkRenderWindow *QmitkViewInitializationView::GetSelectedRenderWindow()
 {
   int selectedItem = m_Controls->m_lbRenderWindows->currentRow();
   int itemNumber = 0;
 
   mitk::BaseRenderer::BaseRendererMapType::iterator mapit;
   for (mapit = mitk::BaseRenderer::baseRendererMap.begin(); mapit != mitk::BaseRenderer::baseRendererMap.end();
        mapit++, itemNumber++)
   {
     if (itemNumber == selectedItem)
       break;
   }
   if (itemNumber == selectedItem)
   {
     return (*mapit).first;
   }
   return nullptr;
 }
 
 void QmitkViewInitializationView::InitRenderWindowSelector()
 {
   itk::SimpleMemberCommand<QmitkViewInitializationView>::Pointer updateRendererListCommand =
     itk::SimpleMemberCommand<QmitkViewInitializationView>::New();
   updateRendererListCommand->SetCallbackFunction(this, &QmitkViewInitializationView::UpdateRendererList);
 
   this->UpdateRendererList();
 }
 
 void QmitkViewInitializationView::UpdateRendererList()
 {
   vtkRenderWindow *focusedRenderWindow = mitk::RenderingManager::GetInstance()->GetFocusedRenderWindow();
 
   int selectedItem = -1;
   int itemNumber = 0;
   m_Controls->m_lbRenderWindows->clear();
 
   for (mitk::BaseRenderer::BaseRendererMapType::iterator mapit = mitk::BaseRenderer::baseRendererMap.begin();
        mapit != mitk::BaseRenderer::baseRendererMap.end();
        mapit++, itemNumber++)
   {
     if ((*mapit).second->GetName())
     {
       m_Controls->m_lbRenderWindows->addItem(QString((*mapit).second->GetName()));
       if (focusedRenderWindow == (*mapit).first)
         selectedItem = itemNumber;
     }
   }
 
   if (selectedItem >= 0)
   {
     m_Controls->m_lbRenderWindows->setCurrentRow(selectedItem);
   }
   else
   {
     m_Controls->m_lbRenderWindows->clearSelection();
   }
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/viewinitialization/QmitkViewInitializationViewControls.ui b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/viewinitialization/QmitkViewInitializationViewControls.ui
index 599028bd2b..3eb0a693d5 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/viewinitialization/QmitkViewInitializationViewControls.ui
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/viewinitialization/QmitkViewInitializationViewControls.ui
@@ -1,161 +1,161 @@
 <ui version="4.0" >
  <class>QmitkViewInitializationViewControls</class>
  <widget class="QWidget" name="QmitkViewInitializationViewControls" >
   <property name="geometry" >
    <rect>
     <x>0</x>
     <y>0</y>
     <width>285</width>
     <height>741</height>
    </rect>
   </property>
   <property name="minimumSize" >
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle" >
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout" >
    <item>
     <widget class="QLabel" name="tlRenderers" >
      <property name="text" >
       <string>Change view initialization of</string>
      </property>
      <property name="wordWrap" >
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QListWidget" name="m_lbRenderWindows" />
    </item>
    <item>
     <widget class="QLabel" name="tlComment" >
      <property name="sizePolicy" >
       <sizepolicy vsizetype="Preferred" hsizetype="MinimumExpanding" >
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize" >
       <size>
        <width>200</width>
        <height>0</height>
       </size>
      </property>
      <property name="text" >
       <string>Change view initialization to</string>
      </property>
      <property name="wordWrap" >
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="bgOrientation" >
      <property name="title" >
       <string>orientation</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2" >
       <item>
        <widget class="QRadioButton" name="rbAxial" >
         <property name="text" >
          <string>axial</string>
         </property>
         <property name="checked" >
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
-       <widget class="QRadioButton" name="rbFrontal" >
+       <widget class="QRadioButton" name="rbCoronal" >
         <property name="text" >
-         <string>frontal</string>
+         <string>coronal</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QRadioButton" name="rbSagittal" >
         <property name="text" >
          <string>sagittal</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox" >
      <property name="title" >
       <string>rotation</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_3" >
       <item>
        <widget class="QCheckBox" name="cbTop" >
         <property name="text" >
          <string>first is top</string>
         </property>
         <property name="checked" >
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="cbFrontSide" >
         <property name="text" >
          <string>front view</string>
         </property>
         <property name="checked" >
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="cbRotated" >
         <property name="text" >
          <string>rotated</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QPushButton" name="pbApply" >
      <property name="text" >
       <string>Apply</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QPushButton" name="pbReset" >
      <property name="text" >
       <string>Reset all</string>
      </property>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer" >
      <property name="orientation" >
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0" >
       <size>
        <width>20</width>
        <height>322</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11" />
  <includes>
   <include location="local" >QmitkDataStorageComboBox.h</include>
  </includes>
  <resources/>
  <connections/>
 </ui>
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/volumetry/QmitkVolumetryView.cpp b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/volumetry/QmitkVolumetryView.cpp
index 97acc0b0b0..eb2ce45ff9 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/volumetry/QmitkVolumetryView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/volumetry/QmitkVolumetryView.cpp
@@ -1,246 +1,252 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkVolumetryView.h"
 
 #include "ui_QmitkVolumetryViewControls.h"
 
 #include "mitkImageStatisticsHolder.h"
 #include "mitkVolumeCalculator.h"
 
 #include <QDir>
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QTextStream>
 
 const std::string QmitkVolumetryView::VIEW_ID = "org.mitk.views.volumetry";
 
 QmitkVolumetryView::QmitkVolumetryView() : m_Controls(nullptr), m_ParentWidget(nullptr)
 {
 }
 
 void QmitkVolumetryView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     m_ParentWidget = parent;
     // create GUI widgets
     m_Controls = new Ui::QmitkVolumetryViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 }
 
 void QmitkVolumetryView::SetFocus()
 {
   m_Controls->m_CalcButton->setFocus();
 }
 
 void QmitkVolumetryView::CreateConnections()
 {
   if (m_Controls)
   {
     connect(
       (QObject *)(m_Controls->m_ThresholdSlider), SIGNAL(valueChanged(int)), this, SLOT(OnThresholdSliderChanged(int)));
     connect((QObject *)(m_Controls->m_CalcButton), SIGNAL(clicked()), this, SLOT(OnCalculateVolume()));
     connect((QObject *)(m_Controls->m_TimeSeriesButton), SIGNAL(clicked()), this, SLOT(OnTimeSeriesButtonClicked()));
     connect((QObject *)(m_Controls->m_SaveCsvButton), SIGNAL(clicked()), this, SLOT(OnSaveCsvButtonClicked()));
   }
 }
 
 void QmitkVolumetryView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
                                             const QList<mitk::DataNode::Pointer> &nodes)
 {
   m_SelectedDataNode = nullptr;
   if (!nodes.isEmpty() && dynamic_cast<mitk::Image *>(nodes.front()->GetData()))
   {
     m_SelectedDataNode = nodes.front();
     m_ParentWidget->setEnabled(true);
   }
 
   if (m_SelectedDataNode.IsExpired() || m_SelectedDataNode == m_OverlayNode)
   {
     m_SelectedDataNode = nullptr;
     m_ParentWidget->setEnabled(false);
     return;
   }
 
   if (m_OverlayNode)
   {
     this->GetDataStorage()->Remove(m_OverlayNode);
     m_OverlayNode = nullptr;
   }
 
   this->CreateOverlayChild();
 
   m_Controls->m_CalcButton->setEnabled(false);
   m_Controls->m_TimeSeriesButton->setEnabled(false);
   m_Controls->m_SaveCsvButton->setEnabled(false);
   m_Controls->m_TextEdit->clear();
 
   mitk::Image *image = dynamic_cast<mitk::Image *>(m_SelectedDataNode.Lock()->GetData());
   image->Update();
   if (image && image->IsInitialized())
   {
     if (image->GetDimension() == 4)
     {
       m_Controls->m_TimeSeriesButton->setEnabled(true);
     }
     else
     {
       m_Controls->m_CalcButton->setEnabled(true);
     }
     int minVal = (int)image->GetStatistics()->GetScalarValue2ndMin();
     int maxVal = (int)image->GetStatistics()->GetScalarValueMaxNoRecompute();
     if (minVal == maxVal)
       --minVal;
     m_Controls->m_ThresholdSlider->setMinimum(minVal);
     m_Controls->m_ThresholdSlider->setMaximum(maxVal);
     m_Controls->m_ThresholdSlider->setEnabled(true);
     this->UpdateSlider();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkVolumetryView::OnCalculateVolume()
 {
-  if (!m_SelectedDataNode.IsExpired())
+  auto selectedDataNode = m_SelectedDataNode.Lock();
+
+  if (selectedDataNode.IsNotNull())
   {
-    mitk::Image *image = dynamic_cast<mitk::Image *>(m_SelectedDataNode.Lock()->GetData());
+    mitk::Image *image = dynamic_cast<mitk::Image *>(selectedDataNode->GetData());
     std::cout << "Dimension:" << image->GetDimension() << std::endl;
     std::cout << "Dimension[3]:" << image->GetDimension(3) << std::endl;
     mitk::VolumeCalculator::Pointer volCalc = mitk::VolumeCalculator::New();
     volCalc->SetImage(image);
     volCalc->SetThreshold(m_Controls->m_ThresholdSlider->value());
     volCalc->ComputeVolume();
     std::stringstream vs;
     vs << volCalc->GetVolume() << " ml";
     m_Controls->m_Result->setText(vs.str().c_str());
   }
 }
 
 void QmitkVolumetryView::OnTimeSeriesButtonClicked()
 {
-  if (!m_SelectedDataNode.IsExpired())
+  auto selectedDataNode = m_SelectedDataNode.Lock();
+
+  if (selectedDataNode.IsNotNull())
   {
-    mitk::Image *image = dynamic_cast<mitk::Image *>(m_SelectedDataNode.Lock()->GetData());
+    mitk::Image *image = dynamic_cast<mitk::Image *>(selectedDataNode->GetData());
     mitk::VolumeCalculator::Pointer volCalc = mitk::VolumeCalculator::New();
     volCalc->SetImage(image);
     volCalc->SetThreshold(m_Controls->m_ThresholdSlider->value());
     volCalc->ComputeVolume();
     std::vector<float> volumes = volCalc->GetVolumes();
     std::stringstream vs;
     int timeStep = 0;
     for (auto it = volumes.begin(); it != volumes.end(); it++)
     {
       vs << timeStep++ << "\t" << *it << std::endl;
     }
     m_Controls->m_TextEdit->setText(vs.str().c_str());
     m_Controls->m_TextEdit->setTabStopWidth(20);
     m_Controls->m_SaveCsvButton->setEnabled(true);
   }
 }
 
 const mitk::DataNode *QmitkVolumetryView::GetImageNode() const
 {
   return m_SelectedDataNode.Lock();
 }
 
 void QmitkVolumetryView::UpdateSlider()
 {
-  if (!m_SelectedDataNode.IsExpired() && dynamic_cast<mitk::Image *>(m_SelectedDataNode.Lock()->GetData()))
+  auto selectedDataNode = m_SelectedDataNode.Lock();
+
+  if (selectedDataNode.IsNotNull() && dynamic_cast<mitk::Image *>(selectedDataNode->GetData()))
   {
     int intSliderValue = (int)m_Controls->m_ThresholdSlider->value();
     QString stringSliderValue;
     stringSliderValue.setNum(intSliderValue);
     m_Controls->m_ThresholdLineEdit->setText(stringSliderValue);
   }
 }
 
 void QmitkVolumetryView::UpdateSliderLabel()
 {
   int sliderValue = atoi(m_Controls->m_ThresholdLineEdit->text().toLatin1());
   m_Controls->m_ThresholdSlider->setValue(sliderValue);
   this->UpdateSlider();
 }
 
 void QmitkVolumetryView::OnThresholdSliderChanged(int value)
 {
   if (m_OverlayNode)
   {
     m_OverlayNode->SetLevelWindow(mitk::LevelWindow(value, 1));
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     this->UpdateSlider();
   }
 }
 
 void QmitkVolumetryView::CreateOverlayChild()
 {
-  if (!m_SelectedDataNode.IsExpired())
-  {
-    auto selectedDataNode = m_SelectedDataNode.Lock();
+  auto selectedDataNode = m_SelectedDataNode.Lock();
 
+  if (selectedDataNode.IsNotNull())
+  {
     m_OverlayNode = mitk::DataNode::New();
     mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New("volume threshold overlay image");
     m_OverlayNode->SetProperty("reslice interpolation", selectedDataNode->GetProperty("reslice interpolation"));
     m_OverlayNode->SetProperty("name", nameProp);
     m_OverlayNode->SetData(selectedDataNode->GetData());
     m_OverlayNode->SetColor(0.0, 1.0, 0.0);
     m_OverlayNode->SetOpacity(.25);
     int layer = 0;
     selectedDataNode->GetIntProperty("layer", layer);
     m_OverlayNode->SetIntProperty("layer", layer + 1);
     m_OverlayNode->SetLevelWindow(mitk::LevelWindow(m_Controls->m_ThresholdSlider->value(), 1));
 
     this->GetDataStorage()->Add(m_OverlayNode);
   }
 }
 
 mitk::DataNode *QmitkVolumetryView::GetOverlayNode() const
 {
   return m_OverlayNode;
 }
 
 mitk::Image *QmitkVolumetryView::GetImage() const
 {
   return dynamic_cast<mitk::Image *>(m_SelectedDataNode.Lock()->GetData());
 }
 
 void QmitkVolumetryView::OnSaveCsvButtonClicked()
 {
   static QString lastSavePath = QDir::homePath();
 
   QString s = QFileDialog::getSaveFileName(this->m_ParentWidget, "Save as..", lastSavePath, "CSV Files (*.csv)");
   /*"Save file dialog"
   "Choose a filename to save under" );*/
 
   if (!s.isEmpty())
   {
     lastSavePath = s;
     QFile saveFile(s);
 
     if (saveFile.open(QIODevice::WriteOnly))
     {
       QTextStream stream(&saveFile);
       stream << m_Controls->m_TextEdit->toPlainText().replace('\t', ';');
       saveFile.close();
     }
     else
     {
       // QMessageBox::critical(nullptr,"Save Error!",QString("Saving of CSV failed! Couldn't open output file \"") +
       // saveFile + QString("\""),QMessageBox:Ok,QMessageBox::NoButton);
       // QMessageBox::critical(nullptr,"Save Error!","Saving of CSV failed! Couldn't open output file \"" + saveFile.name()
       // +"\"",QMessageBox::Ok,QMessageBox::NoButton);
     }
   }
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.opencv/src/internal/videoplayer/QmitkVideoPlayer.cpp b/Examples/Plugins/org.mitk.example.gui.opencv/src/internal/videoplayer/QmitkVideoPlayer.cpp
index 1ae80a56e5..5d58b70e00 100644
--- a/Examples/Plugins/org.mitk.example.gui.opencv/src/internal/videoplayer/QmitkVideoPlayer.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.opencv/src/internal/videoplayer/QmitkVideoPlayer.cpp
@@ -1,60 +1,59 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkVideoPlayer.h"
 #include <QVBoxLayout>
 #include <QmitkOpenCVVideoControls.h>
-#include <QmitkStdMultiWidget.h>
 #include <QmitkVideoBackground.h>
 
 QmitkVideoPlayer::QmitkVideoPlayer() : m_VideoSource(nullptr), m_VideoBackground(new QmitkVideoBackground(m_VideoSource))
 {
 }
 
 QmitkVideoPlayer::~QmitkVideoPlayer()
 {
   // save video preferences
 }
 
 void QmitkVideoPlayer::CreateQtPartControl(QWidget *parent)
 {
   // retrieve old preferences
   m_VideoSource = mitk::OpenCVVideoSource::New();
   m_VideoBackground = new QmitkVideoBackground(m_VideoSource);
   m_VideoBackground->setParent(parent);
 
   QVBoxLayout *layout = new QVBoxLayout;
   QmitkRenderWindow *renderWindow = nullptr;
   if (this->GetRenderWindowPart())
   {
     renderWindow = this->GetRenderWindowPart()->GetActiveQmitkRenderWindow();
   }
   m_OpenCVVideoControls = new QmitkOpenCVVideoControls(m_VideoBackground, renderWindow);
   layout->addWidget(m_OpenCVVideoControls);
 
   parent->setLayout(layout);
 }
 
 void QmitkVideoPlayer::SetFocus()
 {
   m_OpenCVVideoControls->setFocus();
 }
 
 void QmitkVideoPlayer::RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart)
 {
   m_OpenCVVideoControls->SetRenderWindow(renderWindowPart->GetActiveQmitkRenderWindow());
 }
 
 void QmitkVideoPlayer::RenderWindowPartDeactivated(mitk::IRenderWindowPart * /*renderWindowPart*/)
 {
   m_OpenCVVideoControls->SetRenderWindow(nullptr);
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.pcaexample/src/internal/PCAExample.h b/Examples/Plugins/org.mitk.example.gui.pcaexample/src/internal/PCAExample.h
index 6e0e4ecea6..684a6f3876 100644
--- a/Examples/Plugins/org.mitk.example.gui.pcaexample/src/internal/PCAExample.h
+++ b/Examples/Plugins/org.mitk.example.gui.pcaexample/src/internal/PCAExample.h
@@ -1,80 +1,77 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef PCAExample_h
 #define PCAExample_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_PCAExampleControls.h"
 
 /**
   \brief PCAExample
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \sa QmitkAbstractView
   \ingroup ${plugin_target}_internal
 */
 class PCAExample : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   PCAExample();
 
   ~PCAExample() override;
 
 protected slots:
 
   /// \brief Called when the user clicks the GUI button
   void BtnPerfomPCAClicked();
 
 protected:
   void CreateQtPartControl(QWidget *parent) override;
 
   void SetFocus() override;
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
                                   const QList<mitk::DataNode::Pointer> &nodes) override;
 
   /** Performs a PCA on a (3D) point set.
    *  @param input Point set to work on.
    *  @param[out] eigenVectors Eigenvectors as computed by the PCA. Returns an empty vector
    *                           if PCA failed or did not run before.
    *  @param[out] eigenValues  Eigenvalues as computed by the PCA. Returns an empty vector
    *                           if PCA failed or did not run before. The ID inside the vector
    *                           corresponds to the ID inside the eigenvector vector. For a 3D
    *                           pointset 3 eigenvalues and -vectors will be computed.
    *  @param[out] pointsMean   Returns the mean/center of the pointset
    */
   bool comutePCA(mitk::PointSet::Pointer input, std::vector<mitk::Vector3D> &eigenVectors, std::vector<double> &eigenValues, mitk::Vector3D &pointsMean);
 
   /** Adds mitk data nodes for all eigenvectors to visualize them in the multi widget. */
   void showEigenvectors(std::vector<mitk::Vector3D> eigenVectors, std::vector<double> eigenValues, mitk::Vector3D center);
 
   mitk::DataNode::Pointer m_Axis1Node;
   mitk::DataNode::Pointer m_Axis2Node;
   mitk::DataNode::Pointer m_Axis3Node;
 
   Ui::PCAExampleControls m_Controls;
 };
 
 #endif // PCAExample_h
diff --git a/Examples/QtFreeRender/QtFreeRender.cpp b/Examples/QtFreeRender/QtFreeRender.cpp
index 227519ac53..9bf7497de4 100644
--- a/Examples/QtFreeRender/QtFreeRender.cpp
+++ b/Examples/QtFreeRender/QtFreeRender.cpp
@@ -1,330 +1,330 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkRenderWindow.h"
 
 #include "mitkCameraController.h"
 #include "mitkDisplayInteractor.h"
 #include "mitkDisplayInteractor.h"
 #include "mitkInteractionConst.h"
 #include "mitkLine.h"
 #include "mitkPlaneGeometryDataMapper2D.h"
 #include "mitkProperties.h"
 #include "mitkVtkLayerController.h"
 #include <mitkProperties.h>
 #include <mitkRenderingManager.h>
 #include <mitkStandaloneDataStorage.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 
 #include "mitkDataStorage.h"
 #include "mitkIOUtil.h"
 
 #include "vtkAnnotatedCubeActor.h"
 #include "vtkCornerAnnotation.h"
 #include "vtkMitkRectangleProp.h"
 #include "vtkOrientationMarkerWidget.h"
 #include "vtkProperty.h"
 #include "vtkRenderWindow.h"
 #include "vtkRenderWindowInteractor.h"
 #include "vtkTextProperty.h"
 
 // us
 #include "usGetModuleContext.h"
 #include "usModuleContext.h"
 
 #include "mitkInteractionEventObserver.h"
 
 //##Documentation
 //## @brief Example of a NON QT DEPENDENT MITK RENDERING APPLICATION.
 
 mitk::RenderWindow::Pointer mitkWidget1;
 mitk::RenderWindow::Pointer mitkWidget2;
 mitk::RenderWindow::Pointer mitkWidget3;
 mitk::RenderWindow::Pointer mitkWidget4;
 
 mitk::DisplayInteractor::Pointer m_DisplayInteractor;
 vtkSmartPointer<vtkMitkRectangleProp> m_RectangleRendering1;
 vtkSmartPointer<vtkMitkRectangleProp> m_RectangleRendering2;
 vtkSmartPointer<vtkMitkRectangleProp> m_RectangleRendering3;
 vtkSmartPointer<vtkMitkRectangleProp> m_RectangleRendering4;
 
 mitk::SliceNavigationController *m_TimeNavigationController = nullptr;
 
 mitk::DataStorage::Pointer m_DataStorage;
 mitk::DataNode::Pointer m_PlaneNode1;
 mitk::DataNode::Pointer m_PlaneNode2;
 mitk::DataNode::Pointer m_PlaneNode3;
 mitk::DataNode::Pointer m_Node;
 
 void InitializeWindows()
 {
   // Set default view directions for SNCs
   mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
   mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
-  mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
+  mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Coronal);
   mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
 
   // initialize m_TimeNavigationController: send time via sliceNavigationControllers
   m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
   m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget1->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget2->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget3->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget4->GetSliceNavigationController(), false);
   mitkWidget1->GetSliceNavigationController()->ConnectGeometrySendEvent(
     mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
 
   // reverse connection between sliceNavigationControllers and m_TimeNavigationController
   mitkWidget1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
 
   mitkWidget4->GetRenderer()->GetVtkRenderer()->SetBackground(0.1, 0.1, 0.1);
   mitkWidget4->GetRenderer()->GetVtkRenderer()->SetBackground(0.5, 0.5, 0.5);
   mitkWidget4->GetRenderer()->GetVtkRenderer()->GradientBackgroundOn();
 
   m_RectangleRendering1 = vtkSmartPointer<vtkMitkRectangleProp>::New();
   m_RectangleRendering1->SetColor(1.0, 0.0, 0.0);
   mitkWidget1->GetRenderer()->GetVtkRenderer()->AddViewProp(m_RectangleRendering1);
 
   m_RectangleRendering2 = vtkSmartPointer<vtkMitkRectangleProp>::New();
   m_RectangleRendering2->SetColor(0.0, 1.0, 0.0);
   mitkWidget2->GetRenderer()->GetVtkRenderer()->AddViewProp(m_RectangleRendering2);
 
   m_RectangleRendering3 = vtkSmartPointer<vtkMitkRectangleProp>::New();
   m_RectangleRendering3->SetColor(0.0, 0.0, 1.0);
   mitkWidget3->GetRenderer()->GetVtkRenderer()->AddViewProp(m_RectangleRendering3);
 
   m_RectangleRendering4 = vtkSmartPointer<vtkMitkRectangleProp>::New();
   m_RectangleRendering4->SetColor(1.0, 1.0, 0.0);
   mitkWidget4->GetRenderer()->GetVtkRenderer()->AddViewProp(m_RectangleRendering4);
 }
 
 void AddDisplayPlaneSubTree()
 {
   // add the displayed planes of the multiwidget to a node to which the subtree
   // @a planesSubTree points ...
 
   float white[3] = {1.0f, 1.0f, 1.0f};
   mitk::PlaneGeometryDataMapper2D::Pointer mapper;
   mitk::IntProperty::Pointer layer = mitk::IntProperty::New(1000);
 
   // ... of widget 1
   m_PlaneNode1 =
     (mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow()))->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
   m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("name", mitk::StringProperty::New("widget1Plane"));
   m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("layer", layer);
   m_PlaneNode1->SetColor(1.0, 0.0, 0.0);
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   m_PlaneNode2 =
     (mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow()))->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
   m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("name", mitk::StringProperty::New("widget2Plane"));
   m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("layer", layer);
   m_PlaneNode2->SetColor(0.0, 1.0, 0.0);
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   m_PlaneNode3 =
     (mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow()))->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
   m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("name", mitk::StringProperty::New("widget3Plane"));
   m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("layer", layer);
   m_PlaneNode3->SetColor(0.0, 0.0, 1.0);
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // AddPlanesToDataStorage
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
   {
     if (m_DataStorage.IsNotNull())
     {
       m_DataStorage->Add(m_PlaneNode1);
       m_DataStorage->Add(m_PlaneNode2);
       m_DataStorage->Add(m_PlaneNode3);
     }
   }
 }
 
 void Fit()
 {
   vtkRenderer *vtkrenderer;
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow())->GetCameraController()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != nullptr)
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != nullptr)
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != nullptr)
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != nullptr)
     vtkrenderer->ResetCamera();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 int main(int argc, char *argv[])
 {
   if (argc < 2)
   {
     fprintf(stderr, "Usage:   %s [filename1] [filename2] ...\n\n", "");
     return 1;
   }
 
   // Create a DataStorage
   m_DataStorage = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for (i = 1; i < argc; ++i)
   {
     // For testing
     if (strcmp(argv[i], "-testing") == 0)
       continue;
 
     std::string filename = argv[i];
     try
     {
       // Read the file and add it as a data node to the data storage
       mitk::DataStorage::SetOfObjects::Pointer nodes = mitk::IOUtil::Load(filename, *m_DataStorage);
 
       for (mitk::DataStorage::SetOfObjects::Iterator nodeIter = nodes->Begin(), nodeIterEnd = nodes->End();
            nodeIter != nodeIterEnd;
            ++nodeIter)
       {
         mitk::DataNode::Pointer node = nodeIter->Value();
         mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
         if (image.IsNotNull())
         {
           // Set the property "volumerendering" to the Boolean value "true"
           node->SetProperty("volumerendering", mitk::BoolProperty::New(false));
           node->SetProperty("name", mitk::StringProperty::New("testimage"));
           node->SetProperty("layer", mitk::IntProperty::New(1));
         }
       }
     }
     catch (...)
     {
       std::cerr << "Could not open file " << filename << std::endl;
       exit(2);
     }
   }
 
   //*************************************************************************
   // Part V: Create window and pass the tree to it
   //*************************************************************************
 
   // Create renderwindows
   mitkWidget1 = mitk::RenderWindow::New();
   mitkWidget2 = mitk::RenderWindow::New();
   mitkWidget3 = mitk::RenderWindow::New();
   mitkWidget4 = mitk::RenderWindow::New();
 
   mitkWidget1->GetRenderer()->PrepareRender();
   mitkWidget2->GetRenderer()->PrepareRender();
   mitkWidget3->GetRenderer()->PrepareRender();
 
   // Tell the renderwindow which (part of) the datastorage to render
   mitkWidget1->GetRenderer()->SetDataStorage(m_DataStorage);
   mitkWidget2->GetRenderer()->SetDataStorage(m_DataStorage);
   mitkWidget3->GetRenderer()->SetDataStorage(m_DataStorage);
   mitkWidget4->GetRenderer()->SetDataStorage(m_DataStorage);
 
   // instantiate display interactor
   if (m_DisplayInteractor.IsNull())
   {
     m_DisplayInteractor = mitk::DisplayInteractor::New();
     m_DisplayInteractor->LoadStateMachine("DisplayInteraction.xml");
     m_DisplayInteractor->SetEventConfig("DisplayConfigMITK.xml");
     // Register as listener via micro services
 
     us::ModuleContext *context = us::GetModuleContext();
     context->RegisterService<mitk::InteractionEventObserver>(m_DisplayInteractor.GetPointer());
   }
   // Use it as a 2D View
   mitkWidget1->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
   mitkWidget2->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
   mitkWidget3->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
   mitkWidget4->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
   mitkWidget1->SetSize(400, 400);
 
   mitkWidget2->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
                                                  mitkWidget1->GetVtkRenderWindow()->GetPosition()[1]);
   mitkWidget2->SetSize(400, 400);
 
   mitkWidget3->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0],
                                                  mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
   mitkWidget3->SetSize(400, 400);
 
   mitkWidget4->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
                                                  mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
   mitkWidget4->SetSize(400, 400);
 
   InitializeWindows();
 
   AddDisplayPlaneSubTree();
 
   Fit();
 
   // Initialize the RenderWindows
   auto geo = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 
   m_DataStorage->Print(std::cout);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   // reinit the mitkVTKEventProvider;
   // this is only necessary once after calling
   // ForceImmediateUpdateAll() for the first time
   mitkWidget1->ReinitEventProvider();
   mitkWidget2->ReinitEventProvider();
   mitkWidget3->ReinitEventProvider();
 
   mitkWidget1->GetVtkRenderWindow()->Render();
   mitkWidget2->GetVtkRenderWindow()->Render();
   mitkWidget3->GetVtkRenderWindow()->Render();
   mitkWidget4->GetVtkRenderWindow()->Render();
   mitkWidget4->GetVtkRenderWindowInteractor()->Start();
 
   return 0;
 }
diff --git a/Examples/Tutorial/Step4/Step4.cpp b/Examples/Tutorial/Step4/Step4.cpp
index 236d2200c0..02c99351c4 100644
--- a/Examples/Tutorial/Step4/Step4.cpp
+++ b/Examples/Tutorial/Step4/Step4.cpp
@@ -1,164 +1,164 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 #include "QmitkSliceWidget.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkStandaloneDataStorage.h"
 #include <mitkIOUtil.h>
 
 #include <QApplication>
 #include <QHBoxLayout>
 #include <itksys/SystemTools.hxx>
 #include <mitkImage.h>
 
 //##Documentation
 //## @brief Use several views to explore data
 //##
 //## As in Step2 and Step3, load one or more data sets (many image,
 //## surface and other formats), but create 3 views on the data.
 //## The QmitkRenderWindow is used for displaying a 3D view as in Step3,
 //## but without volume-rendering.
 //## Furthermore, we create two 2D views for slicing through the data.
 //## We use the class QmitkSliceWidget, which is based on the class
 //## QmitkRenderWindow, but additionally provides sliders
 //## to slice through the data. We create two instances of
 //## QmitkSliceWidget, one for axial and one for sagittal slicing.
 //## The two slices are also shown at their correct position in 3D as
 //## well as intersection-line, each in the other 2D view.
 int main(int argc, char *argv[])
 {
   QApplication qtapplication(argc, argv);
 
   if (argc < 2)
   {
     fprintf(
       stderr, "Usage:   %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str());
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for (i = 1; i < argc; ++i)
   {
     // For testing
     if (strcmp(argv[i], "-testing") == 0)
       continue;
 
     //*********************************************************************
     // Part III: Put the data into the datastorage
     //*********************************************************************
     // Load datanode (eg. many image formats, surface formats, etc.)
     mitk::IOUtil::Load(argv[i], *ds);
   }
 
   //*************************************************************************
   // Part IV: Create windows and pass the tree to it
   //*************************************************************************
 
   // Create toplevel widget with horizontal layout
   QWidget toplevelWidget;
   QHBoxLayout layout;
   layout.setSpacing(2);
   layout.setMargin(0);
   toplevelWidget.setLayout(&layout);
 
   //*************************************************************************
   // Part IVa: 3D view
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow renderWindow(&toplevelWidget);
   layout.addWidget(&renderWindow);
 
   // Tell the renderwindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // Use it as a 3D view
   renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
   // Reposition the camera to include all visible actors
   renderWindow.GetRenderer()->GetVtkRenderer()->ResetCamera();
 
   // *******************************************************
   // ****************** START OF NEW PART ******************
   // *******************************************************
 
   //*************************************************************************
   // Part IVb: 2D view for slicing axially
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view2(&toplevelWidget);
   layout.addWidget(&view2);
   view2.SetLevelWindowEnabled(true);
   // Tell the QmitkSliceWidget which (part of) the tree to render.
   // By default, it slices the data axially
   view2.SetDataStorage(ds);
 
   // Get the image from the data storage. A predicate (mitk::NodePredicateBase)
   // is used to get only nodes of the type mitk::Image.
   mitk::DataStorage::SetOfObjects::ConstPointer rs = ds->GetSubset(mitk::TNodePredicateDataType<mitk::Image>::New());
 
   view2.SetData(rs->Begin(), mitk::SliceNavigationController::Axial);
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the datastorage!
   ds->Add(view2.GetRenderer()->GetCurrentWorldPlaneGeometryNode());
 
   //*************************************************************************
-  // Part IVc: 2D view for slicing sagitally
+  // Part IVc: 2D view for slicing sagittally
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view3(&toplevelWidget);
   layout.addWidget(&view3);
   view3.SetDataStorage(ds);
   // Tell the QmitkSliceWidget which (part of) the datastorage to render
-  // and to slice sagitally
+  // and to slice sagittally
   view3.SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the datastorage!
   ds->Add(view3.GetRenderer()->GetCurrentWorldPlaneGeometryNode());
 
   // *******************************************************
   // ******************* END OF NEW PART *******************
   // *******************************************************
 
   //*************************************************************************
   // Part V: Qt-specific initialization
   //*************************************************************************
   toplevelWidget.show();
 
   return qtapplication.exec();
 }
 
 /**
 \example Step4.cpp
 */
diff --git a/Examples/Tutorial/Step5/Step5.cpp b/Examples/Tutorial/Step5/Step5.cpp
index 6e3204d641..9faeac9d64 100644
--- a/Examples/Tutorial/Step5/Step5.cpp
+++ b/Examples/Tutorial/Step5/Step5.cpp
@@ -1,203 +1,203 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 #include "QmitkSliceWidget.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkStandaloneDataStorage.h"
 
 #include "mitkPointSet.h"
 // NEW INCLUDE
 #include "mitkPointSetDataInteractor.h"
 
 #include <QApplication>
 #include <QHBoxLayout>
 #include <itksys/SystemTools.hxx>
 #include <mitkIOUtil.h>
 
 //##Documentation
 //## @brief Interactively add points
 //##
 //## As in Step4, load one or more data sets (many image,
 //## surface and other formats) and create 3 views on the data.
 //## Additionally, we want to interactively add points. A node containing
 //## a PointSet as data is added to the data tree and a PointSetDataInteractor
 //## is associated with the node, which handles the interaction. The
 //## @em interaction @em pattern is defined in a state-machine, stored in an
 //## external XML file. Thus, we need to load a state-machine
 //## The interaction patterns defines the @em events,
 //## on which the interactor reacts (e.g., which mouse buttons are used to
 //## set a point), the @em transition to the next state (e.g., the initial
 //## may be "empty point set") and associated @a actions (e.g., add a point
 //## at the position where the mouse-click occured).
 int main(int argc, char *argv[])
 {
   QApplication qtapplication(argc, argv);
 
   if (argc < 2)
   {
     fprintf(
       stderr, "Usage:   %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str());
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for (i = 1; i < argc; ++i)
   {
     // For testing
     if (strcmp(argv[i], "-testing") == 0)
       continue;
 
     // Load datanode (eg. many image formats, surface formats, etc.)
     mitk::StandaloneDataStorage::SetOfObjects::Pointer dataNodes = mitk::IOUtil::Load(argv[i], *ds);
 
     //*********************************************************************
     // Part III: Put the data into the datastorage
     //*********************************************************************
     // Add the node to the DataStorage
     if (dataNodes->empty())
     {
       fprintf(stderr, "Could not open file %s \n\n", argv[i]);
       exit(2);
     }
   }
 
   //*************************************************************************
   // Part V: Create windows and pass the tree to it
   //*************************************************************************
 
   // Create toplevel widget with horizontal layout
   QWidget toplevelWidget;
   QHBoxLayout layout;
   layout.setSpacing(2);
   layout.setMargin(0);
   toplevelWidget.setLayout(&layout);
 
   //*************************************************************************
   // Part Va: 3D view
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow renderWindow(&toplevelWidget);
   layout.addWidget(&renderWindow);
 
   // Tell the renderwindow which (part of) the tree to render
 
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // Use it as a 3D view
   renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
   // Reposition the camera to include all visible actors
   renderWindow.GetRenderer()->GetVtkRenderer()->ResetCamera();
 
   //*************************************************************************
   // Part Vb: 2D view for slicing axially
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view2(&toplevelWidget);
   layout.addWidget(&view2);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render.
   // By default, it slices the data axially
   view2.SetDataStorage(ds);
   mitk::DataStorage::SetOfObjects::ConstPointer rs = ds->GetSubset(mitk::TNodePredicateDataType<mitk::Image>::New());
   view2.SetData(rs->Begin(), mitk::SliceNavigationController::Axial);
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   ds->Add(view2.GetRenderer()->GetCurrentWorldPlaneGeometryNode());
 
   //*************************************************************************
-  // Part Vc: 2D view for slicing sagitally
+  // Part Vc: 2D view for slicing sagittally
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view3(&toplevelWidget);
   layout.addWidget(&view3);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render
-  // and to slice sagitall
+  // and to slice sagittally
   view3.SetDataStorage(ds);
   view3.SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
 
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   ds->Add(view3.GetRenderer()->GetCurrentWorldPlaneGeometryNode());
 
   // *******************************************************
   // ****************** START OF NEW PART ******************
   // *******************************************************
 
   //*************************************************************************
   // Part VI: For allowing to interactively add points ...
   //*************************************************************************
 
   // ATTENTION: It is very important that the renderer already know their DataStorage,
   // because registerig DataInteractors with the render windows is done automatically
   // and only works if the BaseRenderer and the DataStorage know each other.
 
   // Create PointSet and a node for it
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
   mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
   // Store the point set in the DataNode
   pointSetNode->SetData(pointSet);
 
   // Add the node to the tree
   ds->Add(pointSetNode);
 
   // Create PointSetDataInteractor
   mitk::PointSetDataInteractor::Pointer interactor = mitk::PointSetDataInteractor::New();
   // Set the StateMachine pattern that describes the flow of the interactions
   interactor->LoadStateMachine("PointSet.xml");
   // Set the configuration file, which describes the user interactions that trigger actions
   // in this file SHIFT + LeftClick triggers add Point, but by modifying this file,
   // it could as well be changes to any other user interaction.
   interactor->SetEventConfig("PointSetConfig.xml");
 
   // Assign the pointSetNode to the interactor,
   // alternatively one could also add the DataInteractor to the pointSetNode using the SetDataInteractor() method.
   interactor->SetDataNode(pointSetNode);
 
   // *******************************************************
   // ******************* END OF NEW PART *******************
   // *******************************************************
 
   //*************************************************************************
   // Part VII: Qt-specific initialization
   //*************************************************************************
   toplevelWidget.show();
 
   return qtapplication.exec();
 }
 /**
 \example Step5.cpp
 */
diff --git a/Examples/Tutorial/Step6/Step6.cpp b/Examples/Tutorial/Step6/Step6.cpp
index cd118fb7fd..0d60afc0f2 100644
--- a/Examples/Tutorial/Step6/Step6.cpp
+++ b/Examples/Tutorial/Step6/Step6.cpp
@@ -1,233 +1,233 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "Step6.h"
 
 #include "QmitkRenderWindow.h"
 #include "QmitkSliceWidget.h"
 
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkPointSet.h"
 #include "mitkPointSetDataInteractor.h"
 
 #include "mitkImageAccessByItk.h"
 
 #include "mitkRenderingManager.h"
 #include <mitkIOUtil.h>
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 //##Documentation
 //## @brief Start region-grower at interactively added points
 Step6::Step6(int argc, char *argv[], QWidget *parent) : QWidget(parent)
 {
   // load data as in the previous steps; a reference to the first loaded
   // image is kept in the member m_FirstImage and used as input for the
   // region growing
   Load(argc, argv);
 }
 
 void Step6::Initialize()
 {
   // setup the widgets as in the previous steps, but with an additional
   // QVBox for a button to start the segmentation
   this->SetupWidgets();
 
   // Create controlsParent widget with horizontal layout
   QWidget *controlsParent = new QWidget(this);
   this->layout()->addWidget(controlsParent);
 
   QHBoxLayout *hlayout = new QHBoxLayout(controlsParent);
   hlayout->setSpacing(2);
 
   QLabel *labelThresholdMin = new QLabel("Lower Threshold:", controlsParent);
   hlayout->addWidget(labelThresholdMin);
 
   m_LineEditThresholdMin = new QLineEdit("-1000", controlsParent);
   hlayout->addWidget(m_LineEditThresholdMin);
 
   QLabel *labelThresholdMax = new QLabel("Upper Threshold:", controlsParent);
   hlayout->addWidget(labelThresholdMax);
 
   m_LineEditThresholdMax = new QLineEdit("-400", controlsParent);
   hlayout->addWidget(m_LineEditThresholdMax);
 
   // create button to start the segmentation and connect its clicked()
   // signal to method StartRegionGrowing
   QPushButton *startButton = new QPushButton("start region growing", controlsParent);
   hlayout->addWidget(startButton);
 
   connect(startButton, SIGNAL(clicked()), this, SLOT(StartRegionGrowing()));
   if (m_FirstImage.IsNull())
     startButton->setEnabled(false);
 
   // as in Step5, create PointSet (now as a member m_Seeds) and
   // associate a interactor to it
 
   m_Seeds = mitk::PointSet::New();
   mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
   pointSetNode->SetData(m_Seeds);
   pointSetNode->SetProperty("layer", mitk::IntProperty::New(2));
   m_DataStorage->Add(pointSetNode);
 
   // Create PointSetDataInteractor
   mitk::PointSetDataInteractor::Pointer interactor = mitk::PointSetDataInteractor::New();
   interactor->LoadStateMachine("PointSet.xml");
   interactor->SetEventConfig("PointSetConfig.xml");
   interactor->SetDataNode(pointSetNode);
 }
 
 int Step6::GetThresholdMin()
 {
   return m_LineEditThresholdMin->text().toInt();
 }
 
 int Step6::GetThresholdMax()
 {
   return m_LineEditThresholdMax->text().toInt();
 }
 
 void Step6::StartRegionGrowing()
 {
   AccessByItk_1(m_FirstImage, RegionGrowing, this);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void Step6::Load(int argc, char *argv[])
 {
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   m_DataStorage = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for (i = 1; i < argc; ++i)
   {
     // For testing
     if (strcmp(argv[i], "-testing") == 0)
       continue;
 
     // Load datanode (eg. many image formats, surface formats, etc.)
     mitk::StandaloneDataStorage::SetOfObjects::Pointer dataNodes = mitk::IOUtil::Load(argv[i], *m_DataStorage);
 
     if (dataNodes->empty())
     {
       fprintf(stderr, "Could not open file %s \n\n", argv[i]);
       exit(2);
     }
 
     mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(dataNodes->at(0)->GetData());
     if ((m_FirstImage.IsNull()) && (image.IsNotNull()))
       m_FirstImage = image;
   }
 }
 
 void Step6::SetupWidgets()
 {
   //*************************************************************************
   // Part I: Create windows and pass the datastorage to it
   //*************************************************************************
 
   // Create toplevel widget with vertical layout
   QVBoxLayout *vlayout = new QVBoxLayout(this);
   vlayout->setMargin(0);
   vlayout->setSpacing(2);
 
   // Create viewParent widget with horizontal layout
   QWidget *viewParent = new QWidget(this);
   vlayout->addWidget(viewParent);
 
   QHBoxLayout *hlayout = new QHBoxLayout(viewParent);
   hlayout->setMargin(0);
   hlayout->setSpacing(2);
 
   //*************************************************************************
   // Part Ia: 3D view
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow *renderWindow = new QmitkRenderWindow(viewParent);
   hlayout->addWidget(renderWindow);
 
   // Tell the renderwindow which (part of) the tree to render
   renderWindow->GetRenderer()->SetDataStorage(m_DataStorage);
 
   // Use it as a 3D view
   renderWindow->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
   // Reposition the camera to include all visible actors
   renderWindow->GetRenderer()->GetVtkRenderer()->ResetCamera();
 
   //*************************************************************************
   // Part Ib: 2D view for slicing axially
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget *view2 = new QmitkSliceWidget(viewParent);
   hlayout->addWidget(view2);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render.
   // By default, it slices the data axially
   view2->SetDataStorage(m_DataStorage);
   mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetAll();
   view2->SetData(rs->Begin(), mitk::SliceNavigationController::Axial);
 
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   m_DataStorage->Add(view2->GetRenderer()->GetCurrentWorldPlaneGeometryNode());
 
   //*************************************************************************
-  // Part Ic: 2D view for slicing sagitally
+  // Part Ic: 2D view for slicing sagittally
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget *view3 = new QmitkSliceWidget(viewParent);
   hlayout->addWidget(view3);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render
-  // and to slice sagitally
+  // and to slice sagittally
   view3->SetDataStorage(m_DataStorage);
   view3->SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
 
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   m_DataStorage->Add(view3->GetRenderer()->GetCurrentWorldPlaneGeometryNode());
 
   //*************************************************************************
   // Part II: handle updates: To avoid unnecessary updates, we have to
   //*************************************************************************
   // define when to update. The RenderingManager serves this purpose, and
   // each RenderWindow has to be registered to it.
   /*mitk::RenderingManager *renderingManager =
    mitk::RenderingManager::GetInstance();
    renderingManager->AddRenderWindow( renderWindow );
    renderingManager->AddRenderWindow( view2->GetRenderWindow() );
    renderingManager->AddRenderWindow( view3->GetRenderWindow() );*/
 }
 
 /**
  \example Step6.cpp
  */
diff --git a/MITKConfig.cmake.in b/MITKConfig.cmake.in
index bedd4e6385..530ee7c6e3 100644
--- a/MITKConfig.cmake.in
+++ b/MITKConfig.cmake.in
@@ -1,313 +1,314 @@
 if(CMAKE_VERSION VERSION_LESS @MITK_CMAKE_MINIMUM_REQUIRED_VERSION@)
   message(FATAL_ERROR "MITK requires at least CMake Version @MITK_CMAKE_MINIMUM_REQUIRED_VERSION@")
 endif()
 
 # The MITK version number
 set(MITK_VERSION_MAJOR "@MITK_VERSION_MAJOR@")
 set(MITK_VERSION_MINOR "@MITK_VERSION_MINOR@")
 set(MITK_VERSION_PATCH "@MITK_VERSION_PATCH@")
 set(MITK_VERSION_STRING "@MITK_VERSION_STRING@")
 
 #-----------------------------------------------------------------------------
 # C++ language standard
 #-----------------------------------------------------------------------------
 
 set(MITK_CXX_STANDARD @MITK_CXX_STANDARD@)
 
 #-----------------------------------------------------------------------------
 # Include required CMake scripts
 #-----------------------------------------------------------------------------
 
 # Update the CMake module path
 set(MITK_CMAKE_MODULE_PATH "@MITK_SOURCE_DIR@/CMake")
 list(APPEND CMAKE_MODULE_PATH ${MITK_CMAKE_MODULE_PATH})
 
 # Standard CMake macros
 include(CMakeParseArguments)
 include(FeatureSummary)
 include(FindPackageHandleStandardArgs)
 include(GenerateExportHeader)
 
 # Include MITK macros
 include(MacroParseArguments)
+include(mitkFunctionAddManifest)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkFunctionCheckMitkCompatibility)
 include(mitkFunctionCheckModuleDependencies)
 include(mitkFunctionConfigureVisualStudioUserProjectFile)
 include(mitkFunctionCreateBlueBerryApplication)
 include(mitkFunctionCreateCommandLineApp)
 include(mitkFunctionCreateModule)
 include(mitkFunctionCreatePlugin)
 include(mitkFunctionCreateProvisioningFile)
 include(mitkFunctionCreateWindowsBatchScript)
 include(mitkFunctionGetLibrarySearchPaths)
 include(mitkFunctionInstallAutoLoadModules)
 include(mitkFunctionInstallCTKPlugin)
 include(mitkFunctionInstallProvisioningFiles)
 include(mitkFunctionInstallThirdPartyCTKPlugins)
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionUseModules)
 include(mitkMacroCreateExecutable)
 include(mitkMacroCreateModuleTests)
 include(mitkMacroFindDependency)
 include(mitkMacroGenerateToolsLibrary)
 include(mitkMacroGetPMDPlatformString)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroMultiplexPicType)
 
 #-----------------------------------------------------------------------------
 # MITK flags and directories
 #-----------------------------------------------------------------------------
 
 # MITK compiler flags
 set(MITK_C_FLAGS "@MITK_C_FLAGS@")
 set(MTTK_C_FLAGS_DEBUG "@MITK_C_FLAGS_DEBUG@")
 set(MITK_C_FLAGS_RELEASE "@MITK_C_FLAGS_RELEASE@")
 set(MITK_CXX_FLAGS "@MITK_CXX_FLAGS@")
 set(MTTK_CXX_FLAGS_DEBUG "@MITK_CXX_FLAGS_DEBUG@")
 set(MITK_CXX_FLAGS_RELEASE "@MITK_CXX_FLAGS_RELEASE@")
 
 # MITK linker flags
 set(MITK_EXE_LINKER_FLAGS "@MITK_EXE_LINKER_FLAGS@")
 set(MITK_SHARED_LINKER_FLAGS "@MITK_SHARED_LINKER_FLAGS@")
 set(MITK_MODULE_LINKER_FLAGS "@MITK_MODULE_LINKER_FLAGS@")
 
 # MITK specific directories
 set(MITK_SOURCE_DIR "@MITK_SOURCE_DIR@")
 set(MITK_BINARY_DIR "@MITK_BINARY_DIR@")
 set(MITK_CMAKE_DIR "@MITK_CMAKE_DIR@")
 
 # MITK output directories
 set(MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY "@MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY@")
 set(MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY "@MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY@")
 set(MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY "@MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY@")
 
 #-----------------------------------------------------------------------------
 # Miscellaneous variables
 #-----------------------------------------------------------------------------
 
 # Internal version numbers, used for approximate compatibility checks
 # of a MITK development version (non-release).
 set(MITK_VERSION_PLUGIN_SYSTEM 2) # dropped legacy BlueBerry plug-in CMake support
 
 set(MITK_DATA_DIR "@MITK_DATA_DIR@")
 set(UTILITIES_DIR "@UTILITIES_DIR@")
 set(REGISTER_QFUNCTIONALITY_CPP_IN "@REGISTER_QFUNCTIONALITY_CPP_IN@")
 set(MITK_DOXYGEN_TAGFILE_NAME "@MITK_DOXYGEN_TAGFILE_NAME@")
 set(MITK_LEGACY_EXPORT_MACRO_NAME 1)
 
 set(DCMTK_CMAKE_DEBUG_POSTFIX @DCMTK_CMAKE_DEBUG_POSTFIX@)
 
 # Get the canonical name of the directory to avoid potential case mismatch,
 # e.g. in the drive letter on Windows.
 get_filename_component(CMAKE_CURRENT_LIST_DIR_REALPATH ${CMAKE_CURRENT_LIST_DIR} REALPATH)
 if(CMAKE_CURRENT_LIST_DIR_REALPATH STREQUAL MITK_BINARY_DIR)
   set(MITK_EXTERNAL_PROJECT_PREFIX @MITK_EXTERNAL_PROJECT_PREFIX@)
 endif()
 
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR "@MITK_MODULES_PACKAGE_DEPENDS_DIR@")
 if(MODULES_PACKAGE_DEPENDS_DIRS)
   list(APPEND MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
   list(REMOVE_DUPLICATES MODULES_PACKAGE_DEPENDS_DIRS)
 else()
   set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 endif()
 
 #-----------------------------------------------------------------------------
 # External dependencies
 #-----------------------------------------------------------------------------
 
 list(APPEND CMAKE_PREFIX_PATH "@MITK_EXTERNAL_PROJECT_PREFIX@")
 
 # -----------------------------------------
 # Qt variables and dependencies
 
 set(MITK_USE_Qt5 @MITK_USE_Qt5@)
 
 if(MITK_USE_Qt5)
   set(MITK_QT5_MINIMUM_VERSION @MITK_QT5_MINIMUM_VERSION@)
   set(MITK_QT5_COMPONENTS @MITK_QT5_COMPONENTS@)
   mitkMacroFindDependency(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS})
 endif()
 
 # -----------------------------------------
 # Special Python variables
 
 set(MITK_USE_Python3 @MITK_USE_Python3@)
 if(MITK_USE_Python3)
   set(PYTHON_EXECUTABLE "@PYTHON_EXECUTABLE@" CACHE FILEPATH "")
   set(PYTHON_INCLUDE_DIR "@PYTHON_INCLUDE_DIR@" CACHE PATH "")
   set(PYTHON_LIBRARY "@PYTHON_LIBRARY@" CACHE FILEPATH "")
   set(PYTHON_INCLUDE_DIR2 "@PYTHON_INCLUDE_DIR2@" CACHE PATH "")
 
   mitkMacroFindDependency(Python3 COMPONENTS Interpreter Development NumPy)
 endif()
 
 # -----------------------------------------
 # Special Boost variables
 
 set(MITK_USE_Boost_LIBRARIES @MITK_USE_Boost_LIBRARIES@)
 set(MITK_USE_SYSTEM_Boost @MITK_USE_SYSTEM_Boost@)
 set(BOOST_ROOT "@BOOST_ROOT@" CACHE PATH "")
 set(BOOST_LIBRARYDIR "@BOOST_LIBRARYDIR@" CACHE PATH "")
 set(Boost_ADDITIONAL_VERSIONS 1.74 1.74.0)
 
 # We need this later for a DCMTK workaround
 set(_dcmtk_dir_orig "@DCMTK_DIR@")
 
 # -----------------------------------------
 # External dependencies from the superbuild
 # or injected from somewhere else via
 # <project>_DIR variables.
 
 @MITK_CONFIG_EXTERNAL_PROJECTS@
 
 # Ensure the MITK module path comes first
 set(CMAKE_MODULE_PATH ${MITK_CMAKE_MODULE_PATH} ${CMAKE_MODULE_PATH})
 
 # -----------------------------------------
 # Special handling for DCMTK
 
 if(MITK_USE_DCMTK)
   # Due to the preferred CONFIG mode in find_package calls above,
   # the DCMTKConfig.cmake file is read, which does not provide useful
   # package information. We explictly need MODULE mode to find DCMTK.
   if(${_dcmtk_dir_orig} MATCHES "${MITK_EXTERNAL_PROJECT_PREFIX}.*")
     # Help our FindDCMTK.cmake script find our super-build DCMTK
     set(DCMTK_DIR ${MITK_EXTERNAL_PROJECT_PREFIX})
   else()
     # Use the original value
     set(DCMTK_DIR ${_dcmtk_dir_orig})
   endif()
   find_package(DCMTK REQUIRED MODULE)
 endif()
 
 # -----------------------------------------
 # Special handling for DCMQI
 if(MITK_USE_DCMQI)
   # Due to the preferred CONFIG mode in find_package calls above,
   # the DCMQIConfig.cmake file is read, which does not provide useful
   # package information. We explictly need MODULE mode to find DCMQI.
     # Help our FindDCMQI.cmake script find our super-build DCMQI
   set(DCMQI_DIR ${MITK_EXTERNAL_PROJECT_PREFIX})
   find_package(DCMQI REQUIRED)
 endif()
 
 # -----------------------------------------
 # Special handling for Boost
 
 if(MITK_USE_Boost)
   link_directories(${Boost_LIBRARY_DIRS})
 endif()
 
 # -----------------------------------------
 # Special handling for OpenIGTLink
 
 if(MITK_USE_OpenIGTLink)
   link_directories(${OpenIGTLink_LIBRARY_DIRS})
 endif()
 
 # -----------------------------------------
 # Internal project dependencies
 
 set(CppMicroServices_DIR "@CppMicroServices_DIR@")
 mitkMacroFindDependency(CppMicroServices)
 
 set(MITK_USE_BLUEBERRY @MITK_USE_BLUEBERRY@)
 if(MITK_USE_BLUEBERRY)
 
   set(MITK_PLUGIN_USE_FILE "@MITK_PLUGIN_USE_FILE@")
   if(MITK_PLUGIN_USE_FILE)
     if(EXISTS "${MITK_PLUGIN_USE_FILE}")
       include("${MITK_PLUGIN_USE_FILE}")
     endif()
   endif()
 
   set(MITK_PLUGIN_PROVISIONING_FILE "@MITK_EXTAPP_PROVISIONING_FILE@")
   set(MITK_PROVISIONING_FILES
       "${BLUEBERRY_PLUGIN_PROVISIONING_FILE}"
       "${MITK_PLUGIN_PROVISIONING_FILE}")
 
 endif()
 
 set(BLUEBERRY_USE_QT_HELP @BLUEBERRY_USE_QT_HELP@)
 if(BLUEBERRY_USE_QT_HELP AND DOXYGEN_VERSION VERSION_LESS "1.8.7")
   message("Setting BLUEBERRY_USE_QT_HELP to OFF because Doxygen version 1.8.7 or newer not found.")
   set(BLUEBERRY_USE_QT_HELP OFF)
 endif()
 
 set(BLUEBERRY_QTPLUGIN_PATH "@BLUEBERRY_QTPLUGIN_PATH@")
 
 set(QT_HELPGENERATOR_EXECUTABLE "@QT_HELPGENERATOR_EXECUTABLE@")
 set(QT_COLLECTIONGENERATOR_EXECUTABLE "@QT_COLLECTIONGENERATOR_EXECUTABLE@")
 set(QT_ASSISTANT_EXECUTABLE "@QT_ASSISTANT_EXECUTABLE@")
 set(QT_XMLPATTERNS_EXECUTABLE "@QT_XMLPATTERNS_EXECUTABLE@")
 
 
 #-----------------------------------------------------------------------------
 # MITK sub-project variables
 #-----------------------------------------------------------------------------
 
 # External SDK directories
 set(MITK_PMD_SDK_DIR @MITK_PMD_SDK_DIR@)
 
 # MITK ToF use variables
 
 set(MITK_TOF_PMDCAMCUBE_AVAILABLE @MITK_USE_TOF_PMDCAMCUBE@)
 if(MITK_TOF_PMDCAMCUBE_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_PMDCAMCUBE "Enable support for PMD Cam Cube" @MITK_USE_TOF_PMDCAMCUBE@)
   mark_as_advanced(MITK_USE_TOF_PMDCAMCUBE)
 endif()
 
 set(MITK_TOF_PMDCAMBOARD_AVAILABLE @MITK_USE_TOF_PMDCAMBOARD@)
 if(MITK_TOF_PMDCAMBOARD_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_PMDCAMBOARD "Enable support for PMD Cam Board" @MITK_USE_TOF_PMDCAMBOARD@)
   mark_as_advanced(MITK_USE_TOF_PMDCAMBOARD)
 endif()
 
 set(MITK_TOF_PMDO3_AVAILABLE @MITK_USE_TOF_PMDO3@)
 if(MITK_TOF_PMDO3_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_PMDO3 "Enable support for PMD =3" @MITK_USE_TOF_PMDO3@)
   mark_as_advanced(MITK_USE_TOF_PMDO3)
 endif()
 
 set(MITK_TOF_KINECT_AVAILABLE @MITK_USE_TOF_KINECT@)
 if(MITK_TOF_KINECT_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_KINECT "Enable support for Kinect" @MITK_USE_TOF_KINECT@)
   mark_as_advanced(MITK_USE_TOF_KINECT)
 endif()
 
 set(MITK_TOF_MESASR4000_AVAILABLE @MITK_USE_TOF_MESASR4000@)
 if(MITK_TOF_MESASR4000_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_MESASR4000 "Enable support for MESA SR4000" @MITK_USE_TOF_MESASR4000@)
   mark_as_advanced(MITK_USE_TOF_MESASR4000)
 endif()
 
 if(MITK_USE_IGT)
   #include("${MITK_DIR}/mitkIGTConfig.cmake")
 endif()
 
 #-----------------------------------------------------------------------------
 # Import MITK targets and set custom properties
 #-----------------------------------------------------------------------------
 
 if(NOT MITK_EXPORTS_FILE_INCLUDED)
   if(EXISTS "@MITK_EXPORTS_FILE@")
     set(MITK_EXPORTS_FILE_INCLUDED 1)
     include("@MITK_EXPORTS_FILE@")
   endif()
 endif()
 
 # Set properties on exported targets
 @MITK_EXPORTED_TARGET_PROPERTIES@
 
 #-----------------------------------------------------------------------------
 # Install rules
 #-----------------------------------------------------------------------------
 
 # Install rules for ToF libraries loaded at runtime
 if(EXISTS "@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake")
   include("@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake")
 endif()
diff --git a/Modules/AlgorithmsExt/src/mitkSegmentationSink.cpp b/Modules/AlgorithmsExt/src/mitkSegmentationSink.cpp
index 48493b47ef..3da0078efc 100644
--- a/Modules/AlgorithmsExt/src/mitkSegmentationSink.cpp
+++ b/Modules/AlgorithmsExt/src/mitkSegmentationSink.cpp
@@ -1,91 +1,94 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkSegmentationSink.h"
 #include "mitkDataStorage.h"
 #include "mitkRenderingManager.h"
 
 namespace mitk
 {
   SegmentationSink::SegmentationSink() {}
   SegmentationSink::~SegmentationSink() {}
   void SegmentationSink::Initialize(const NonBlockingAlgorithm *other)
   {
     Superclass::Initialize(other);
     // sinks should be called explicitly from the tool, because otherwise the order of setting "Input" and "Group node"
     // would matter
     UnDefineTriggerParameter("Input");
 
     // some basedata output
     DataNode::Pointer groupNode;
     bool showResult(true);
 
     if (other)
     {
       other->GetPointerParameter("Group node", groupNode);
       other->GetParameter("Show result", showResult);
     }
 
     SetPointerParameter("Group node", groupNode);
     SetParameter("Show result", showResult);
   }
 
   bool SegmentationSink::ReadyToRun()
   {
     Image::Pointer image;
     GetPointerParameter("Input", image);
 
     DataNode::Pointer groupNode;
     GetPointerParameter("Group node", groupNode);
 
     return image.IsNotNull() && groupNode.IsNotNull();
   }
 
   bool SegmentationSink::ThreadedUpdateFunction() { return true; }
   /// to be called by subclasses when they want to insert some resulting object (binary image, surface, ...) into the
   /// data tree
   void SegmentationSink::InsertBelowGroupNode(mitk::DataNode *node)
   {
     DataNode *groupNode = GetGroupNode();
 
-    if (!m_DataStorage.IsExpired())
+    auto dataStorage = m_DataStorage.Lock();
+
+    if (dataStorage.IsNotNull())
     {
       if (node)
         node->GetData()->DisconnectPipeline();
-      m_DataStorage.Lock()->Add(node, groupNode);
+      dataStorage->Add(node, groupNode);
     }
 
     RenderingManager::GetInstance()->RequestUpdateAll();
   }
 
   DataNode *SegmentationSink::GetGroupNode()
   {
     DataNode::Pointer groupNode;
     GetPointerParameter("Group node", groupNode);
 
     return groupNode.GetPointer();
   }
 
   DataNode *SegmentationSink::LookForPointerTargetBelowGroupNode(const char *name)
   {
     DataNode::Pointer groupNode;
     GetPointerParameter("Group node", groupNode);
+    auto dataStorage = m_DataStorage.Lock();
 
-    if (groupNode.IsNotNull() && !m_DataStorage.IsExpired())
+    if (groupNode.IsNotNull() && dataStorage.IsNotNull())
     {
-      return m_DataStorage.Lock()->GetNamedDerivedNode(name, groupNode, true);
+      return dataStorage->GetNamedDerivedNode(name, groupNode, true);
     }
 
     return nullptr;
   }
 
 } // namespace
diff --git a/Modules/Annotation/include/mitkTextAnnotation3D.h b/Modules/Annotation/include/mitkTextAnnotation3D.h
index 79301558da..f07f7ec06c 100644
--- a/Modules/Annotation/include/mitkTextAnnotation3D.h
+++ b/Modules/Annotation/include/mitkTextAnnotation3D.h
@@ -1,81 +1,81 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef TextAnnotation3D_H
 #define TextAnnotation3D_H
 
 #include "MitkAnnotationExports.h"
 #include <mitkLocalStorageHandler.h>
 #include <mitkVtkAnnotation3D.h>
 
 class vtkFollower;
 class vtkVectorText;
 class vtkTextActor3D;
 
 namespace mitk
 {
   /** \brief Displays at 3D position, always facing the camera */
   class MITKANNOTATION_EXPORT TextAnnotation3D : public mitk::VtkAnnotation3D
   {
   public:
     /** \brief Internal class holding the mapper, actor, etc. for each of the render windows */
     /**
-       * To render the Annotation on transveral, coronal, and sagittal, the update method
+       * To render the Annotation on axial, coronal, and sagittal, the update method
        * is called for each renderwindow. For performance reasons, the corresponding data
        * for each view is saved in the internal helper class LocalStorage.
        * This allows rendering n views with just 1 mitkAnnotation using n vtkMapper.
        * */
     class LocalStorage : public mitk::Annotation::BaseLocalStorage
     {
     public:
       /** \brief Actor of a 2D render window. */
       vtkSmartPointer<vtkFollower> m_follower;
 
       vtkSmartPointer<vtkVectorText> m_textSource;
 
       /** \brief Timestamp of last update of stored data. */
       itk::TimeStamp m_LastUpdateTime;
 
       /** \brief Default constructor of the local storage. */
       LocalStorage();
       /** \brief Default deconstructor of the local storage. */
       ~LocalStorage();
     };
 
     mitkClassMacro(TextAnnotation3D, mitk::VtkAnnotation3D);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       protected :
 
       /** \brief The LocalStorageHandler holds all LocalStorages for the render windows. */
       mutable mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
     vtkProp *GetVtkProp(BaseRenderer *renderer) const override;
     void UpdateVtkAnnotation(mitk::BaseRenderer *renderer) override;
 
     /** \brief explicit constructor which disallows implicit conversions */
     explicit TextAnnotation3D();
 
     /** \brief virtual destructor in order to derive from this class */
     ~TextAnnotation3D() override;
 
   private:
     /** \brief copy constructor */
     TextAnnotation3D(const TextAnnotation3D &);
 
     /** \brief assignment operator */
     TextAnnotation3D &operator=(const TextAnnotation3D &);
   };
 
 } // namespace mitk
 #endif // TextAnnotation3D_H
diff --git a/Modules/AppUtil/include/mitkBaseApplication.h b/Modules/AppUtil/include/mitkBaseApplication.h
index ad11d6f08a..00cca3ef7d 100644
--- a/Modules/AppUtil/include/mitkBaseApplication.h
+++ b/Modules/AppUtil/include/mitkBaseApplication.h
@@ -1,319 +1,320 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkBaseApplication_h
 #define mitkBaseApplication_h
 
 #include <MitkAppUtilExports.h>
 
 #include <Poco/Util/Application.h>
 
 #include <QString>
 #include <QVariant>
 
 class ctkPluginContext;
 class ctkPluginFramework;
 
 class QCoreApplication;
 class QTranslator;
 
 namespace mitk
 {
   /**
    * A utility class for starting BlueBerry applications.
    *
    * In the simplest case, create an instance of this class and call run().
    * This will launch a CTK plugin framework instance and execute the
    * default application registered by a plug-in via the
    * org.blueberry.osgi.applications extension point.
    *
    * This class contains many convenience methods to:
    *  - Put the application in <em>safe mode</em> which catches unhandled
    *    exceptions thrown in the Qt event loop and displays an error
    *    message.
    *  - Put the application in <em>single mode</em> which by default
    *    sends the command line arguments to an already running instance
    *    of the same application instead of creating a second instance.
    *  - Add a list of library names which should be pre-loaded at
    *    application start-up, e.g. to speed up the initial launch during
    *    the caching process of the plug-in meta-data.
    *  - Set a custom provisioning file to start a specific set of CTK
    *    plug-ins during application start-up.
    *  - Set and get CTK plugin framework properties
    *
    * The behavior can further be customized by deriving from BaseApplication
    * and overriding specific methods, such as:
    *  - initializeLibraryPaths() to add specific library / plugin search paths
    *  - defineOptions(Poco::Util::OptionSet&) to define a custom set of
    *    command line options
    *  - getQApplication() to provide a custom QCoreApplication instance
    *
    * A simple but complete example:
    * \code
    * #include <mitkBaseApplication.h>
    *
    * int main(int argc, char* argv[])
    * {
    *   mitk::BaseApplication app(argc, argv);
    *   app.setApplicationName("MyApp");
    *   app.setOrganizationName("MyOrganization");
    *
    *   // Run the workbench
    *   return app.run();
    * }
    * \endcode
    */
   class MITKAPPUTIL_EXPORT BaseApplication : public Poco::Util::Application
   {
   public:
     // Command line arguments
 
     static const QString ARG_APPLICATION;
     static const QString ARG_CLEAN;
     static const QString ARG_CONSOLELOG;
     static const QString ARG_DEBUG;
     static const QString ARG_FORCE_PLUGIN_INSTALL;
     static const QString ARG_HOME;
     static const QString ARG_NEWINSTANCE;
     static const QString ARG_NO_LAZY_REGISTRY_CACHE_LOADING;
     static const QString ARG_NO_REGISTRY_CACHE;
     static const QString ARG_PLUGIN_CACHE;
     static const QString ARG_PLUGIN_DIRS;
     static const QString ARG_PRELOAD_LIBRARY;
     static const QString ARG_PRODUCT;
     static const QString ARG_PROVISIONING;
     static const QString ARG_REGISTRY_MULTI_LANGUAGE;
     static const QString ARG_SPLASH_IMAGE;
     static const QString ARG_STORAGE_DIR;
     static const QString ARG_XARGS;
     static const QString ARG_LOG_QT_MESSAGES;
     static const QString ARG_SEGMENTATION_LABELSET_PRESET;
+    static const QString ARG_SEGMENTATION_LABEL_SUGGESTIONS;
 
     // BlueBerry specific plugin framework properties
 
     static const QString PROP_APPLICATION;
     static const QString PROP_FORCE_PLUGIN_INSTALL;
     static const QString PROP_NEWINSTANCE;
     static const QString PROP_NO_LAZY_REGISTRY_CACHE_LOADING;
     static const QString PROP_NO_REGISTRY_CACHE;
     static const QString PROP_PRODUCT;
     static const QString PROP_REGISTRY_MULTI_LANGUAGE;
 
     BaseApplication(int argc, char **argv);
     ~BaseApplication() override;
 
     /**
      * Initialize the Qt library such that a QCoreApplication
      * instance is available and e.g. Qt widgets can be created.
      *
      * This is usually not called directly by the user.
      */
     void initializeQt();
 
     /**
      * Launches the BlueBerry framework and runs the default application
      * or the one specified in the PROP_APPLICATION framework property.
      *
      * @return The return code of the application after it was shut down.
      */
     int run() override;
 
     void printHelp(const std::string &name, const std::string &value);
 
     /**
      * Set the application name. Same as QCoreApplication::setApplicationName.
      * @param name The application name.
      */
     void setApplicationName(const QString &name);
     QString getApplicationName() const;
 
     /**
      * Set the organization name. Same as QCoreApplication::setOrganizationName.
      * @param name The organization name.
      */
     void setOrganizationName(const QString &name);
     QString getOrganizationName() const;
 
     /**
      * Set the organization domain. Same as QCoreApplication::setOrganizationDomain.
      * @param name The organization domain.
      */
     void setOrganizationDomain(const QString &name);
     QString getOrganizationDomain() const;
 
     /**
      * Put the application in single mode, which by default only allows
      * a single instance of the application to be created.
      *
      * Calling this method after run() has been called has no effect.
      *
      * @param singleMode
      */
     void setSingleMode(bool singleMode);
     bool getSingleMode() const;
 
     /**
      * Put the application in safe mode, catching exceptions from the
      * Qt event loop.
      *
      * @param safeMode
      */
     void setSafeMode(bool safeMode);
     bool getSafeMode() const;
 
     /**
      * Set a list of library names or absoulte file paths
      * which should be loaded at application start-up. The name
      * and file path may contain a library version appended at the
      * end and separated by a '$' charactger.
      *
      * For example <code>liborg_mitk_gui_qt_common$1.0</code>.
      * Platform specific suffixes are appended automatically.
      *
      * @param libraryBaseNames A list of library base names.
      */
     void setPreloadLibraries(const QStringList &libraryBaseNames);
 
     /**
      * Get the list of library base names which should be pre-loaded.
      *
      * @return A list of pre-loaded libraries.
      */
     QStringList getPreloadLibraries() const;
 
     /**
      * Set the path to the provisioning file.
      *
      * By default a provisioning file located in the same directory
      * as the executable and named \<executable\>.provisioning
      * is loaded if it exists. To disable parsing of provisioning
      * files, use an empty string as the argument. Use a
      * null QString (\c QString::null ) to reset to the
      * default behaviour.
      *
      * @param filePath An absolute file path to the provisioning file.
      */
     void setProvisioningFilePath(const QString &filePath);
 
     /**
      * Get the file path to the provisioning file.
      * @return The provisioning file path.
      */
     QString getProvisioningFilePath() const;
 
     void setProperty(const QString &property, const QVariant &value);
     QVariant getProperty(const QString &property) const;
 
     void installTranslator(QTranslator*);
 
     bool isRunning();
 
     void sendMessage(const QByteArray);
 
   protected:
     void initialize(Poco::Util::Application &self) override;
 
     void uninitialize() override;
 
     int getArgc() const;
     char **getArgv() const;
 
     /**
      * Get the framework storage directory for the CTK plugin
      * framework. This method is called in the initialize(Poco::Util::Application&)
      * method. It must not be called without a QCoreApplications instance.
      *
      * @return The CTK Plugin Framework storage directory.
      */
     virtual QString getCTKFrameworkStorageDir() const;
 
     /**
      * Initialize the CppMicroServices library.
      *
      * The default implementation set the CppMicroServices storage
      * path to the current ctkPluginConstants::FRAMEWORK_STORAGE property
      * value.
      *
      * This method is called in the initialize(Poco::Util::Application&)
      * after the CTK Plugin Framework storage directory property
      * was set.
      */
     virtual void initializeCppMicroServices();
 
     /**
      * Get the QCoreApplication object.
      *
      * This method is called in the initialize(Poco::Util::Application&)
      * method and must create a QCoreApplication instance if the
      * global qApp variable is not initialized yet.
      *
      * @return The current QCoreApplication instance. This method
      * never returns null.
      */
     virtual QCoreApplication *getQApplication() const;
 
     /**
      * Add plugin library search paths to the CTK Plugin Framework.
      *
      * This method is called in the nitialize(Poco::Util::Application&)
      * method after getQApplication() was called.
      */
     virtual void initializeLibraryPaths();
 
     /**
      * Runs the application for which the platform was started. The platform
      * must be running.
      * <p>
      * The given argument is passed to the application being run.  If it is an invalid QVariant
      * then the command line arguments used in starting the platform, and not consumed
      * by the platform code, are passed to the application as a <code>QStringList</code>.
      * </p>
      * @param args the argument passed to the application. May be <code>invalid</code>
      * @return the result of running the application
      * @throws std::exception if anything goes wrong
      */
     int main(const std::vector<std::string> &args) override;
 
     /**
      * Define command line arguments
      * @param options
      */
     void defineOptions(Poco::Util::OptionSet &options) override;
 
     QSharedPointer<ctkPluginFramework> getFramework() const;
     ctkPluginContext *getFrameworkContext() const;
 
     /**
      * Get the initial properties for the CTK plugin framework.
      *
      * The returned map contains the initial framework properties for
      * initializing the CTK plugin framework. The value of specific
      * properties may change at runtime and differ from the initial
      * value.
      *
      * @return The initial CTK Plugin Framework properties.
      */
     QHash<QString, QVariant> getFrameworkProperties() const;
 
     /*
     * Initialize and display the splash screen if an image filename is given
     *
     */
     void initializeSplashScreen(QCoreApplication * application) const;
 
 private:
     struct Impl;
     Impl* d;
   };
 }
 
 #endif // MITKBASEAPPLICATION_H
diff --git a/Modules/AppUtil/src/mitkBaseApplication.cpp b/Modules/AppUtil/src/mitkBaseApplication.cpp
index 28aa7a35b0..0b8cfb0814 100644
--- a/Modules/AppUtil/src/mitkBaseApplication.cpp
+++ b/Modules/AppUtil/src/mitkBaseApplication.cpp
@@ -1,880 +1,885 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkBaseApplication.h>
 
 #include <mitkExceptionMacro.h>
 #include <mitkLogMacros.h>
 #include <mitkProvisioningInfo.h>
 
 #include <QmitkSafeApplication.h>
 #include <QmitkSingleApplication.h>
 
 #include <Poco/Util/HelpFormatter.h>
 
 #include <ctkPluginFramework.h>
 #include <ctkPluginFramework_global.h>
 #include <ctkPluginFrameworkLauncher.h>
 
 #include <usModuleSettings.h>
 
 #include <vtkOpenGLRenderWindow.h>
 #include <QVTKOpenGLNativeWidget.h>
 
 #include <QCoreApplication>
 #include <QDir>
 #include <QFileInfo>
 #include <QRunnable>
 #include <QSplashScreen>
 #include <QStandardPaths>
 #include <QTime>
 #include <QWebEngineUrlScheme>
 
 namespace
 {
   void outputQtMessage(QtMsgType type, const QMessageLogContext&, const QString& msg)
   {
     auto message = msg.toStdString();
 
     switch (type)
     {
       case QtDebugMsg:
         MITK_DEBUG << message;
         break;
 
       case QtInfoMsg:
         MITK_INFO << message;
         break;
 
       case QtWarningMsg:
         MITK_WARN << message;
         break;
 
       case QtCriticalMsg:
         MITK_ERROR << message;
         break;
 
       case QtFatalMsg:
         MITK_ERROR << message;
         abort();
 
       default:
         MITK_INFO << message;
         break;
     }
   }
 }
 
 namespace mitk
 {
   const QString BaseApplication::ARG_APPLICATION = "BlueBerry.application";
   const QString BaseApplication::ARG_CLEAN = "BlueBerry.clean";
   const QString BaseApplication::ARG_CONSOLELOG = "BlueBerry.consoleLog";
   const QString BaseApplication::ARG_DEBUG = "BlueBerry.debug";
   const QString BaseApplication::ARG_FORCE_PLUGIN_INSTALL = "BlueBerry.forcePlugins";
   const QString BaseApplication::ARG_HOME = "BlueBerry.home";
   const QString BaseApplication::ARG_NEWINSTANCE = "BlueBerry.newInstance";
   const QString BaseApplication::ARG_NO_LAZY_REGISTRY_CACHE_LOADING = "BlueBerry.noLazyRegistryCacheLoading";
   const QString BaseApplication::ARG_NO_REGISTRY_CACHE = "BlueBerry.noRegistryCache";
   const QString BaseApplication::ARG_PLUGIN_CACHE = "BlueBerry.plugin_cache_dir";
   const QString BaseApplication::ARG_PLUGIN_DIRS = "BlueBerry.plugin_dirs";
   const QString BaseApplication::ARG_PRELOAD_LIBRARY = "BlueBerry.preloadLibrary";
   const QString BaseApplication::ARG_PRODUCT = "BlueBerry.product";
   const QString BaseApplication::ARG_PROVISIONING = "BlueBerry.provisioning";
   const QString BaseApplication::ARG_REGISTRY_MULTI_LANGUAGE = "BlueBerry.registryMultiLanguage";
   const QString BaseApplication::ARG_SPLASH_IMAGE = "BlueBerry.splashscreen";
   const QString BaseApplication::ARG_STORAGE_DIR = "BlueBerry.storageDir";
   const QString BaseApplication::ARG_XARGS = "xargs";
   const QString BaseApplication::ARG_LOG_QT_MESSAGES = "Qt.logMessages";
   const QString BaseApplication::ARG_SEGMENTATION_LABELSET_PRESET = "Segmentation.labelSetPreset";
+  const QString BaseApplication::ARG_SEGMENTATION_LABEL_SUGGESTIONS = "Segmentation.labelSuggestions";
 
   const QString BaseApplication::PROP_APPLICATION = "blueberry.application";
   const QString BaseApplication::PROP_FORCE_PLUGIN_INSTALL = BaseApplication::ARG_FORCE_PLUGIN_INSTALL;
   const QString BaseApplication::PROP_NEWINSTANCE = BaseApplication::ARG_NEWINSTANCE;
   const QString BaseApplication::PROP_NO_LAZY_REGISTRY_CACHE_LOADING = BaseApplication::ARG_NO_LAZY_REGISTRY_CACHE_LOADING;
   const QString BaseApplication::PROP_NO_REGISTRY_CACHE = BaseApplication::ARG_NO_REGISTRY_CACHE;
   const QString BaseApplication::PROP_PRODUCT = "blueberry.product";
   const QString BaseApplication::PROP_REGISTRY_MULTI_LANGUAGE = BaseApplication::ARG_REGISTRY_MULTI_LANGUAGE;
 
   class SplashCloserCallback : public QRunnable
   {
   public:
     SplashCloserCallback(QSplashScreen* splashscreen)
       : m_Splashscreen(splashscreen)
     {
     }
 
     void run() override
     {
       this->m_Splashscreen->close();
     }
 
   private:
     QSplashScreen *m_Splashscreen; // Owned by BaseApplication::Impl
   };
 
   struct BaseApplication::Impl
   {
     ctkProperties m_FWProps;
 
     QCoreApplication *m_QApp;
 
     int m_Argc;
     char **m_Argv;
 
 #ifdef Q_OS_MAC
     std::vector<char*> m_Argv_macOS;
 #endif
 
     QString m_AppName;
     QString m_OrgaName;
     QString m_OrgaDomain;
 
     bool m_SingleMode;
     bool m_SafeMode;
 
     QSplashScreen *m_Splashscreen;
     SplashCloserCallback *m_SplashscreenClosingCallback;
 
     bool m_LogQtMessages;
 
     QStringList m_PreloadLibs;
     QString m_ProvFile;
 
     Impl(int argc, char **argv)
       : m_Argc(argc),
         m_Argv(argv),
 #ifdef Q_OS_MAC
         m_Argv_macOS(),
 #endif
         m_SingleMode(false),
         m_SafeMode(true),
         m_Splashscreen(nullptr),
         m_SplashscreenClosingCallback(nullptr),
         m_LogQtMessages(false)
     {
 #ifdef Q_OS_MAC
       /* On macOS the process serial number is passed as an command line argument (-psn_<NUMBER>)
          in certain circumstances. This option causes a Poco exception. We remove it, if present. */
 
       m_Argv_macOS.reserve(argc + 1);
 
       const char psn[] = "-psn";
 
       for (int i = 0; i < argc; ++i)
       {
         if (0 == strncmp(argv[i], psn, sizeof(psn) - 1))
           continue;
 
         m_Argv_macOS.push_back(argv[i]);
       }
 
       m_Argv_macOS.push_back(nullptr);
 
       m_Argc = static_cast<decltype(m_Argc)>(m_Argv_macOS.size() - 1);
       m_Argv = m_Argv_macOS.data();
 #endif
     }
 
     ~Impl()
     {
       delete m_SplashscreenClosingCallback;
       delete m_Splashscreen;
       delete m_QApp;
     }
 
     QVariant getProperty(const QString &property) const
     {
       auto iter = m_FWProps.find(property);
 
       return m_FWProps.end() != iter
         ? iter.value()
         : QVariant();
     }
 
     void handleBooleanOption(const std::string &name, const std::string &)
     {
       if (ARG_LOG_QT_MESSAGES.toStdString() == name)
       {
         m_LogQtMessages = true;
         return;
       }
 
       auto fwKey = QString::fromStdString(name);
 
       // Translate some keys to proper framework properties
       if (ARG_CONSOLELOG == fwKey)
         fwKey = ctkPluginFrameworkLauncher::PROP_CONSOLE_LOG;
 
       // For all other options we use the command line option name as the
       // framework property key.
       m_FWProps[fwKey] = true;
     }
 
     void handlePreloadLibraryOption(const std::string &, const std::string &value)
     {
       m_PreloadLibs.push_back(QString::fromStdString(value));
     }
 
     void handleClean(const std::string &, const std::string &)
     {
       m_FWProps[ctkPluginConstants::FRAMEWORK_STORAGE_CLEAN] = ctkPluginConstants::FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT;
     }
 
     void initializeCTKPluginFrameworkProperties(Poco::Util::LayeredConfiguration &configuration)
     {
       // Add all configuration key/value pairs as framework properties
       Poco::Util::LayeredConfiguration::Keys keys;
 
       Poco::Util::LayeredConfiguration::Keys keyStack;
       configuration.keys(keyStack);
 
       std::vector<std::string> keyChain;
 
       while (!keyStack.empty())
       {
         const auto currSubKey = keyStack.back();
 
         if (!keyChain.empty() && keyChain.back() == currSubKey)
         {
           keyChain.pop_back();
           keyStack.pop_back();
           continue;
         }
 
         Poco::Util::LayeredConfiguration::Keys subKeys;
         configuration.keys(currSubKey, subKeys);
 
         if (subKeys.empty())
         {
           std::string finalKey;
           keyStack.pop_back();
 
           for (const auto& key : keyChain)
             finalKey += key + '.';
 
           finalKey += currSubKey;
           keys.push_back(finalKey);
         }
         else
         {
           keyChain.push_back(currSubKey);
 
           for (const auto& key : subKeys)
             keyStack.push_back(key);
         }
       }
 
       for (const auto& key : keys)
       {
         if (configuration.hasProperty(key))
         {
           // .ini and command line options overwrite already inserted keys
           auto qKey = QString::fromStdString(key);
           m_FWProps[qKey] = QString::fromStdString(configuration.getString(key));
         }
       }
     }
 
     void parseProvisioningFile(const QString &filePath)
     {
       // Skip parsing if the file path is empty
       if (filePath.isEmpty())
         return;
 
       auto consoleLog = this->getProperty(ctkPluginFrameworkLauncher::PROP_CONSOLE_LOG).toBool();
 
       // Read initial plugins from a provisioning file
       QFileInfo provFile(filePath);
       QStringList pluginsToStart;
 
       if (provFile.exists())
       {
         MITK_INFO(consoleLog) << "Using provisioning file: " << qPrintable(provFile.absoluteFilePath());
         ProvisioningInfo provInfo(provFile.absoluteFilePath());
 
         // It can still happen that the encoding is not compatible with the fromUtf8 function (i.e. when
         // manipulating the LANG variable). The QStringList in provInfo is empty then.
         if (provInfo.getPluginDirs().empty())
         {
           MITK_ERROR << "Cannot search for provisioning file, the retrieved directory list is empty.\n"
                      << "This can happen if there are some special non-ASCII characters in the install path.";
         }
         else
         {
           for(const auto& pluginPath : provInfo.getPluginDirs())
             ctkPluginFrameworkLauncher::addSearchPath(pluginPath);
 
           auto pluginUrlsToStart = provInfo.getPluginsToStart();
 
           for (const auto& url : qAsConst(pluginUrlsToStart))
             pluginsToStart.push_back(url.toString());
         }
       }
       else
       {
         MITK_INFO(consoleLog) << "Provisionig file does not exist.";
       }
 
       if (!pluginsToStart.isEmpty())
       {
         m_FWProps[ctkPluginFrameworkLauncher::PROP_PLUGINS] = pluginsToStart;
 
         // Use transient start with declared activation policy (this helps when the provisioning file
         // changes and some plug-ins should not be installed in the application any more).
         ctkPlugin::StartOptions startOptions(ctkPlugin::START_TRANSIENT | ctkPlugin::START_ACTIVATION_POLICY);
         m_FWProps[ctkPluginFrameworkLauncher::PROP_PLUGINS_START_OPTIONS] = static_cast<int>(startOptions);
       }
     }
   };
 
   BaseApplication::BaseApplication(int argc, char **argv)
     : Application(),
       d(new Impl(argc, argv))
   {
   }
 
   BaseApplication::~BaseApplication()
   {
     delete d;
   }
 
   void BaseApplication::printHelp(const std::string &, const std::string &)
   {
     Poco::Util::HelpFormatter help(this->options());
     help.setAutoIndent();
     help.setCommand(this->commandName());
     help.format(std::cout);
 
     exit(EXIT_OK);
   }
 
   void BaseApplication::setApplicationName(const QString &name)
   {
     if (nullptr != qApp)
       qApp->setApplicationName(name);
 
     d->m_AppName = name;
   }
 
   QString BaseApplication::getApplicationName() const
   {
     return nullptr != qApp
       ? qApp->applicationName()
       : d->m_AppName;
   }
 
   void BaseApplication::setOrganizationName(const QString &name)
   {
     if (nullptr != qApp)
       qApp->setOrganizationName(name);
 
     d->m_OrgaName = name;
   }
 
   QString BaseApplication::getOrganizationName() const
   {
     return nullptr != qApp
       ? qApp->organizationName()
       : d->m_OrgaName;
   }
 
   void BaseApplication::setOrganizationDomain(const QString &domain)
   {
     if (nullptr != qApp)
       qApp->setOrganizationDomain(domain);
 
     d->m_OrgaDomain = domain;
   }
 
   QString BaseApplication::getOrganizationDomain() const
   {
     return nullptr != qApp
       ? qApp->organizationDomain()
       : d->m_OrgaDomain;
   }
 
   void BaseApplication::setSingleMode(bool singleMode)
   {
     if (nullptr != qApp)
       return;
 
     d->m_SingleMode = singleMode;
   }
 
   bool BaseApplication::getSingleMode() const
   {
     return d->m_SingleMode;
   }
 
   void BaseApplication::setSafeMode(bool safeMode)
   {
     if (nullptr != qApp && nullptr == d->m_QApp)
       return;
 
     d->m_SafeMode = safeMode;
 
     nullptr == d->m_QApp && getSingleMode()
       ? static_cast<QmitkSingleApplication *>(d->m_QApp)->setSafeMode(safeMode)
       : static_cast<QmitkSafeApplication *>(d->m_QApp)->setSafeMode(safeMode);
   }
 
   bool BaseApplication::getSafeMode() const
   {
     return d->m_SafeMode;
   }
 
   void BaseApplication::setPreloadLibraries(const QStringList &libraryBaseNames)
   {
     d->m_PreloadLibs = libraryBaseNames;
   }
 
   QStringList BaseApplication::getPreloadLibraries() const
   {
     return d->m_PreloadLibs;
   }
 
   void BaseApplication::setProvisioningFilePath(const QString &filePath)
   {
     d->m_ProvFile = filePath;
   }
 
   QString BaseApplication::getProvisioningFilePath() const
   {
     auto provFilePath = d->m_ProvFile;
 
     // A null QString means look up a default provisioning file
     if (provFilePath.isNull() && nullptr != qApp)
     {
       QFileInfo appFilePath(QCoreApplication::applicationFilePath());
       QDir basePath(QCoreApplication::applicationDirPath());
 
       auto provFileName = appFilePath.baseName() + ".provisioning";
 
       QFileInfo provFile(basePath.absoluteFilePath(provFileName));
 
 #ifdef Q_OS_MAC
       /*
        * On macOS, if started from the build directory, the .provisioning file is located at:
        * <MITK-build/bin/MitkWorkbench.provisioning>
        * The executable path is:
        * <MITK-build/bin/MitkWorkbench.app/Contents/MacOS/MitkWorkbench>
        * In this case we have to cdUp threetimes.
        *
        * During packaging the MitkWorkbench.provisioning file is placed at the same
        * level like the executable. Nothing has to be done.
        */
 
       if (!provFile.exists())
       {
         basePath.cdUp();
         basePath.cdUp();
         basePath.cdUp();
         provFile = basePath.absoluteFilePath(provFileName);
       }
 #endif
 
       if (provFile.exists())
       {
         provFilePath = provFile.absoluteFilePath();
       }
 #ifdef CMAKE_INTDIR
       else
       {
         basePath.cdUp();
         provFile.setFile(basePath.absoluteFilePath(provFileName));
 
         if (provFile.exists())
           provFilePath = provFile.absoluteFilePath();
       }
 #endif
     }
 
     return provFilePath;
   }
 
   void BaseApplication::initializeQt()
   {
     if (nullptr != qApp)
       return;
 
     // If parameters have been set before, we have to store them to hand them
     // through to the application
     auto appName = this->getApplicationName();
     auto orgName = this->getOrganizationName();
     auto orgDomain = this->getOrganizationDomain();
 
     // Create a QCoreApplication instance
     this->getQApplication();
 
     // Provide parameters to QCoreApplication
     this->setApplicationName(appName);
     this->setOrganizationName(orgName);
     this->setOrganizationDomain(orgDomain);
 
     if (d->m_LogQtMessages)
       qInstallMessageHandler(outputQtMessage);
 
     QWebEngineUrlScheme qtHelpScheme("qthelp");
     qtHelpScheme.setFlags(QWebEngineUrlScheme::LocalScheme | QWebEngineUrlScheme::LocalAccessAllowed);
     QWebEngineUrlScheme::registerScheme(qtHelpScheme);
   }
 
   void BaseApplication::initialize(Poco::Util::Application &self)
   {
     // 1. Call the super-class method
     Poco::Util::Application::initialize(self);
 
     // 2. Initialize the Qt framework (by creating a QCoreApplication)
     this->initializeQt();
 
     // 3. Seed the random number generator, once at startup.
     QTime time = QTime::currentTime();
     qsrand((uint)time.msec());
 
     // 4. Load the "default" configuration, which involves parsing
     //    an optional <executable-name>.ini file and parsing any
     //    command line arguments
     this->loadConfiguration();
 
     // 5. Add configuration data from the command line and the
     //    optional <executable-name>.ini file as CTK plugin
     //    framework properties.
     d->initializeCTKPluginFrameworkProperties(this->config());
 
     // 6. Initialize splash screen if an image path is provided
     //    in the .ini file
     this->initializeSplashScreen(qApp);
 
     // 7. Set the custom CTK Plugin Framework storage directory
     QString storageDir = this->getCTKFrameworkStorageDir();
 
     if (!storageDir.isEmpty())
       d->m_FWProps[ctkPluginConstants::FRAMEWORK_STORAGE] = storageDir;
 
     // 8. Set the library search paths and the pre-load library property
     this->initializeLibraryPaths();
 
     auto preloadLibs = this->getPreloadLibraries();
 
     if (!preloadLibs.isEmpty())
       d->m_FWProps[ctkPluginConstants::FRAMEWORK_PRELOAD_LIBRARIES] = preloadLibs;
 
     // 9. Initialize the CppMicroServices library.
     //    The initializeCppMicroServices() method reuses the
     //    FRAMEWORK_STORAGE property, so we call it after the
     //    getCTKFrameworkStorageDir method.
     this->initializeCppMicroServices();
 
     // 10. Parse the (optional) provisioning file and set the
     //     correct framework properties.
     d->parseProvisioningFile(this->getProvisioningFilePath());
 
     // 11. Set the CTK Plugin Framework properties
     ctkPluginFrameworkLauncher::setFrameworkProperties(d->m_FWProps);
   }
 
   void BaseApplication::uninitialize()
   {
     auto pfw = this->getFramework();
 
     if (pfw)
     {
       pfw->stop();
       // Wait for up to 10 seconds for the CTK plugin framework to stop
       pfw->waitForStop(10000);
     }
 
     Poco::Util::Application::uninitialize();
   }
 
   int BaseApplication::getArgc() const
   {
     return d->m_Argc;
   }
 
   char **BaseApplication::getArgv() const
   {
     return d->m_Argv;
   }
 
   QString BaseApplication::getCTKFrameworkStorageDir() const
   {
     QString storageDir;
 
     if (this->getSingleMode())
     {
       // This function checks if an instance is already running and either sends a message to
       // it containing the command line arguments or checks if a new instance was forced by
       // providing the BlueBerry.newInstance command line argument. In the latter case, a path
       // to a temporary directory for the new application's storage directory is returned.
       storageDir = handleNewAppInstance(static_cast<QtSingleApplication *>(d->m_QApp),
         d->m_Argc, d->m_Argv, ARG_NEWINSTANCE);
     }
 
     if (storageDir.isEmpty())
     {
       // This is a new instance and no other instance is already running. We specify the
       // storage directory here (this is the same code as in berryInternalPlatform.cpp)
       // so that we can re-use the location for the persistent data location of the
       // the CppMicroServices library.
 
       // Append a hash value of the absolute path of the executable to the data location.
       // This allows to start the same application from different build or install trees.
       storageDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/" +
                    this->getOrganizationName() + "/" + this->getApplicationName() + '_';
       storageDir += QString::number(qHash(QCoreApplication::applicationDirPath())) + "/";
     }
 
     return storageDir;
   }
 
   void BaseApplication::initializeCppMicroServices()
   {
     auto storageDir = this->getProperty(ctkPluginConstants::FRAMEWORK_STORAGE).toString();
 
     if (!storageDir.isEmpty())
       us::ModuleSettings::SetStoragePath((storageDir + "us" + QDir::separator()).toStdString());
   }
 
   QCoreApplication *BaseApplication::getQApplication() const
   {
     if (nullptr == qApp)
     {
       vtkOpenGLRenderWindow::SetGlobalMaximumNumberOfMultiSamples(0);
 
       auto defaultFormat = QVTKOpenGLNativeWidget::defaultFormat();
       defaultFormat.setSamples(0);
       QSurfaceFormat::setDefaultFormat(defaultFormat);
 
 #ifdef Q_OS_OSX
       QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
 #endif
 
       QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
 
       d->m_QApp = this->getSingleMode()
         ? static_cast<QCoreApplication*>(new QmitkSingleApplication(d->m_Argc, d->m_Argv, this->getSafeMode()))
         : static_cast<QCoreApplication*>(new QmitkSafeApplication(d->m_Argc, d->m_Argv, this->getSafeMode()));
     }
 
     return qApp;
   }
 
   void BaseApplication::initializeLibraryPaths()
   {
     QStringList suffixes;
     suffixes << "plugins";
 
 #ifdef Q_OS_WINDOWS
     suffixes << "bin/plugins";
   #ifdef CMAKE_INTDIR
     suffixes << "bin/" CMAKE_INTDIR "/plugins";
   #endif
 #else
     suffixes << "lib/plugins";
   #ifdef CMAKE_INTDIR
     suffixes << "lib/" CMAKE_INTDIR "/plugins";
   #endif
 #endif
 
 #ifdef Q_OS_MAC
     suffixes << "../../plugins";
 #endif
 
     // We add a couple of standard library search paths for plug-ins
     QDir appDir(QCoreApplication::applicationDirPath());
 
     // Walk one directory up and add bin and lib sub-dirs; this might be redundant
     appDir.cdUp();
 
     for (const auto& suffix : qAsConst(suffixes))
       ctkPluginFrameworkLauncher::addSearchPath(appDir.absoluteFilePath(suffix));
   }
 
   int BaseApplication::main(const std::vector<std::string> &args)
   {
     // Start the plugin framework and all installed plug-ins according to their auto-start setting
     QStringList arguments;
 
     for (auto const &arg : args)
       arguments.push_back(QString::fromStdString(arg));
 
     if (nullptr != d->m_Splashscreen)
     {
       // A splash screen is displayed. Create the closing callback.
       d->m_SplashscreenClosingCallback = new SplashCloserCallback(d->m_Splashscreen);
     }
 
     return ctkPluginFrameworkLauncher::run(d->m_SplashscreenClosingCallback, QVariant::fromValue(arguments)).toInt();
   }
 
   void BaseApplication::defineOptions(Poco::Util::OptionSet &options)
   {
     Poco::Util::Option helpOption("help", "h", "print this help text");
     helpOption.callback(Poco::Util::OptionCallback<BaseApplication>(this, &BaseApplication::printHelp));
     options.addOption(helpOption);
 
     Poco::Util::Option newInstanceOption(ARG_NEWINSTANCE.toStdString(), "", "forces a new instance of this application");
     newInstanceOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
     options.addOption(newInstanceOption);
 
     Poco::Util::Option cleanOption(ARG_CLEAN.toStdString(), "", "cleans the plugin cache");
     cleanOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleClean));
     options.addOption(cleanOption);
 
     Poco::Util::Option productOption(ARG_PRODUCT.toStdString(), "", "the id of the product to be launched");
     productOption.argument("<id>").binding(PROP_PRODUCT.toStdString());
     options.addOption(productOption);
 
     Poco::Util::Option appOption(ARG_APPLICATION.toStdString(), "", "the id of the application extension to be executed");
     appOption.argument("<id>").binding(PROP_APPLICATION.toStdString());
     options.addOption(appOption);
 
     Poco::Util::Option provOption(ARG_PROVISIONING.toStdString(), "", "the location of a provisioning file");
     provOption.argument("<prov file>").binding(ARG_PROVISIONING.toStdString());
     options.addOption(provOption);
 
     Poco::Util::Option storageDirOption(ARG_STORAGE_DIR.toStdString(), "", "the location for storing persistent application data");
     storageDirOption.argument("<dir>").binding(ctkPluginConstants::FRAMEWORK_STORAGE.toStdString());
     options.addOption(storageDirOption);
 
     Poco::Util::Option consoleLogOption(ARG_CONSOLELOG.toStdString(), "", "log messages to the console");
     consoleLogOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
     options.addOption(consoleLogOption);
 
     Poco::Util::Option debugOption(ARG_DEBUG.toStdString(), "", "enable debug mode");
     debugOption.argument("<options file>", false).binding(ctkPluginFrameworkLauncher::PROP_DEBUG.toStdString());
     options.addOption(debugOption);
 
     Poco::Util::Option forcePluginOption(ARG_FORCE_PLUGIN_INSTALL.toStdString(), "", "force installing plug-ins with same symbolic name");
     forcePluginOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
     options.addOption(forcePluginOption);
 
     Poco::Util::Option preloadLibsOption(ARG_PRELOAD_LIBRARY.toStdString(), "", "preload a library");
     preloadLibsOption.argument("<library>")
       .repeatable(true)
       .callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handlePreloadLibraryOption));
     options.addOption(preloadLibsOption);
 
     Poco::Util::Option noRegistryCacheOption(ARG_NO_REGISTRY_CACHE.toStdString(), "", "do not use a cache for the registry");
     noRegistryCacheOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
     options.addOption(noRegistryCacheOption);
 
     Poco::Util::Option noLazyRegistryCacheLoadingOption(ARG_NO_LAZY_REGISTRY_CACHE_LOADING.toStdString(), "", "do not use lazy cache loading for the registry");
     noLazyRegistryCacheLoadingOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
     options.addOption(noLazyRegistryCacheLoadingOption);
 
     Poco::Util::Option registryMultiLanguageOption(ARG_REGISTRY_MULTI_LANGUAGE.toStdString(), "", "enable multi-language support for the registry");
     registryMultiLanguageOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
     options.addOption(registryMultiLanguageOption);
 
   Poco::Util::Option splashScreenOption(ARG_SPLASH_IMAGE.toStdString(), "", "optional picture to use as a splash screen");
   splashScreenOption.argument("<filename>").binding(ARG_SPLASH_IMAGE.toStdString());
   options.addOption(splashScreenOption);
 
     Poco::Util::Option xargsOption(ARG_XARGS.toStdString(), "", "Extended argument list");
     xargsOption.argument("<args>").binding(ARG_XARGS.toStdString());
     options.addOption(xargsOption);
 
     Poco::Util::Option logQtMessagesOption(ARG_LOG_QT_MESSAGES.toStdString(), "", "log Qt messages");
     logQtMessagesOption.callback(Poco::Util::OptionCallback<Impl>(d, &Impl::handleBooleanOption));
     options.addOption(logQtMessagesOption);
 
     Poco::Util::Option labelSetPresetOption(ARG_SEGMENTATION_LABELSET_PRESET.toStdString(), "", "use this label set preset for new segmentations");
     labelSetPresetOption.argument("<filename>").binding(ARG_SEGMENTATION_LABELSET_PRESET.toStdString());
     options.addOption(labelSetPresetOption);
 
+    Poco::Util::Option labelSuggestionsOption(ARG_SEGMENTATION_LABEL_SUGGESTIONS.toStdString(), "", "use this list of predefined suggestions for segmentation labels");
+    labelSuggestionsOption.argument("<filename>").binding(ARG_SEGMENTATION_LABEL_SUGGESTIONS.toStdString());
+    options.addOption(labelSuggestionsOption);
+
     Poco::Util::Application::defineOptions(options);
   }
 
   QSharedPointer<ctkPluginFramework> BaseApplication::getFramework() const
   {
     return ctkPluginFrameworkLauncher::getPluginFramework();
   }
 
   ctkPluginContext *BaseApplication::getFrameworkContext() const
   {
     auto framework = getFramework();
 
     return framework
       ? framework->getPluginContext()
       : nullptr;
   }
 
   void BaseApplication::initializeSplashScreen(QCoreApplication * application) const
   {
     auto pixmapFileNameProp = d->getProperty(ARG_SPLASH_IMAGE);
 
     if (!pixmapFileNameProp.isNull())
     {
       auto pixmapFileName = pixmapFileNameProp.toString();
       QFileInfo checkFile(pixmapFileName);
 
       if (checkFile.exists() && checkFile.isFile())
       {
         QPixmap pixmap(checkFile.absoluteFilePath());
 
         d->m_Splashscreen = new QSplashScreen(pixmap, Qt::WindowStaysOnTopHint);
         d->m_Splashscreen->show();
 
         application->processEvents();
       }
     }
   }
 
   QHash<QString, QVariant> BaseApplication::getFrameworkProperties() const
   {
     return d->m_FWProps;
   }
 
   int BaseApplication::run()
   {
     this->init(d->m_Argc, d->m_Argv);
     return Application::run();
   }
 
   void BaseApplication::setProperty(const QString &property, const QVariant &value)
   {
     d->m_FWProps[property] = value;
   }
 
   QVariant BaseApplication::getProperty(const QString &property) const
   {
     return d->getProperty(property);
   }
 
   void BaseApplication::installTranslator(QTranslator* translator)
   {
     this->getQApplication()->installTranslator(translator);
   }
 
   bool BaseApplication::isRunning()
   {
     auto app = dynamic_cast<QtSingleApplication*>(this->getQApplication());
 
     if (nullptr != app)
       app->isRunning();
 
     mitkThrow() << "Method not implemented.";
   }
 
   void BaseApplication::sendMessage(const QByteArray msg)
   {
     auto app = dynamic_cast<QtSingleApplication*>(this->getQApplication());
 
     if (nullptr != app)
       app->sendMessage(msg);
 
     mitkThrow() << "Method not implemented.";
   }
 }
diff --git a/Modules/CEST/CMakeLists.txt b/Modules/CEST/CMakeLists.txt
index a35980ee61..467700c299 100644
--- a/Modules/CEST/CMakeLists.txt
+++ b/Modules/CEST/CMakeLists.txt
@@ -1,9 +1,9 @@
 MITK_CREATE_MODULE(
   DEPENDS MitkCore
     PRIVATE MitkDICOM
   PACKAGE_DEPENDS
-    PRIVATE Poco
+    PRIVATE Poco nlohmann_json
 )
 
 add_subdirectory(autoload/IO)
 add_subdirectory(test)
diff --git a/Modules/CEST/autoload/IO/CMakeLists.txt b/Modules/CEST/autoload/IO/CMakeLists.txt
index 9b6aa610fa..73ef3d9ca0 100644
--- a/Modules/CEST/autoload/IO/CMakeLists.txt
+++ b/Modules/CEST/autoload/IO/CMakeLists.txt
@@ -1,4 +1,5 @@
 MITK_CREATE_MODULE( CESTIO
   DEPENDS MitkCEST MitkDICOM
+  PACKAGE_DEPENDS PRIVATE nlohmann_json
   AUTOLOAD_WITH MitkDICOM
 )
diff --git a/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp b/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp
index 0276670704..3070b9d2b1 100644
--- a/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp
+++ b/Modules/CEST/autoload/IO/mitkCESTGenericDICOMReaderService.cpp
@@ -1,407 +1,409 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkCESTGenericDICOMReaderService.h"
 
 #include "mitkIOMimeTypes.h"
 #include <mitkExtractCESTOffset.h>
 #include <mitkCustomTagParser.h>
 #include <mitkCESTPropertyHelper.h>
 #include <mitkDICOMDCMTKTagScanner.h>
 #include <mitkDICOMFileReaderSelector.h>
 #include <mitkDICOMProperty.h>
 
 #include "mitkCESTImageNormalizationFilter.h"
 
 #include "itksys/SystemTools.hxx"
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
-#include <boost/property_tree/json_parser.hpp>
-#include <boost/property_tree/ptree.hpp>
+#include <nlohmann/json.hpp>
+
+using namespace nlohmann;
 
 namespace
 {
   std::string OPTION_NAME_B1()
   {
     return "B1 amplitude";
   }
 
   std::string OPTION_NAME_PULSE()
   {
     return "Pulse duration [us]";
   }
 
   std::string OPTION_NAME_DC()
   {
     return "Duty cycle [%]";
   }
 
   std::string OPTION_NAME_NORMALIZE()
   {
     return "Normalize data";
   }
 
   std::string OPTION_NAME_NORMALIZE_AUTOMATIC()
   {
     return "Automatic";
   }
 
   std::string OPTION_NAME_NORMALIZE_NO()
   {
     return "No";
   }
 
   std::string OPTION_NAME_MERGE()
   {
     return "Merge all series";
   }
 
   std::string OPTION_NAME_MERGE_YES()
   {
     return "Yes";
   }
 
   std::string OPTION_NAME_MERGE_NO()
   {
     return "No";
   }
 
   std::string META_FILE_OPTION_NAME_MERGE()
   {
     return "CEST.MergeAllSeries";
   }
 
 }
 
 namespace mitk
 {
   DICOMTagPath DICOM_IMAGING_FREQUENCY_PATH()
   {
     return mitk::DICOMTagPath(0x0018, 0x0084);
   }
 
   CESTDICOMManualReaderService::CESTDICOMManualReaderService(const CustomMimeType& mimeType, const std::string& description)
     : BaseDICOMReaderService(mimeType, description)
   {
     IFileIO::Options options;
     options[OPTION_NAME_B1()] = 0.0;
     options[OPTION_NAME_PULSE()] = 0.0;
     options[OPTION_NAME_DC()] = 0.0;
     std::vector<std::string> normalizationStrategy;
     normalizationStrategy.push_back(OPTION_NAME_NORMALIZE_AUTOMATIC());
     normalizationStrategy.push_back(OPTION_NAME_NORMALIZE_NO());
     options[OPTION_NAME_NORMALIZE()] = normalizationStrategy;
     std::vector<std::string> mergeStrategy;
     mergeStrategy.push_back(OPTION_NAME_MERGE_NO());
     mergeStrategy.push_back(OPTION_NAME_MERGE_YES());
     options[OPTION_NAME_MERGE()] = mergeStrategy;
     this->SetDefaultOptions(options);
 
     this->RegisterService();
   }
 
   namespace
   {
-    void ExtractOptionFromPropertyTree(const std::string& key, boost::property_tree::ptree& root, std::map<std::string, us::Any>& options)
+    void ExtractOptionFromPropertyTree(const std::string& key, const json& root, std::map<std::string, us::Any>& options)
     {
-      auto finding = root.find(key);
-      if (finding != root.not_found())
+      if (root.contains(key))
       {
-        try
+        const auto& value = root[key];
+
+        if (value.is_number_float())
         {
-          options[key] = finding->second.get_value<double>();
+          options[key] = value.get<double>();
         }
-        catch (const boost::property_tree::ptree_bad_data& /*e*/)
+        else
         {
-          options[key] = finding->second.get_value<std::string>();
+          options[key] = value.get<std::string>();
         }
       }
     }
 
     IFileIO::Options ExtractOptionsFromFile(const std::string& file)
     {
-      boost::property_tree::ptree root;
+      json root;
 
       if (itksys::SystemTools::FileExists(file))
       {
         try
         {
-          boost::property_tree::read_json(file, root, std::locale("C"));
+          root = json::parse(file);
         }
-        catch (const boost::property_tree::json_parser_error & e)
+        catch (const json::exception& e)
         {
           MITK_WARN << "Could not parse CEST meta file. Fall back to default values. Error was:\n" << e.what();
         }
       }
       else
       {
         MITK_DEBUG << "CEST meta file does not exist. Fall back to default values. CEST meta file path: " << file;
       }
 
       IFileIO::Options options;
       ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_B1Amplitude(), root, options);
       ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_PULSEDURATION(), root, options);
       ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_DutyCycle(), root, options);
       ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_OFFSETS(), root, options);
       ExtractOptionFromPropertyTree(CEST_PROPERTY_NAME_TREC(), root, options);
       ExtractOptionFromPropertyTree(META_FILE_OPTION_NAME_MERGE(), root, options);
 
       return options;
     }
 
     void TransferOption(const mitk::IFileIO::Options& sourceOptions, const std::string& sourceName, mitk::IFileIO::Options& options, const std::string& newName)
     {
       auto sourceFinding = sourceOptions.find(sourceName);
       auto finding = options.find(newName);
 
       bool replaceValue = finding == options.end();
       if (!replaceValue)
       {
         replaceValue = us::any_cast<double>(finding->second) == 0.;
       }
 
       if (sourceFinding != sourceOptions.end() && us::any_cast<double>(sourceFinding->second) != 0. && replaceValue)
       {
         options[newName] = sourceFinding->second;
       }
     }
 
     void TransferMergeOption(const mitk::IFileIO::Options& sourceOptions, const std::string& sourceName, mitk::IFileIO::Options& options, const std::string& newName)
     {
       auto sourceFinding = sourceOptions.find(sourceName);
       auto finding = options.find(newName);
 
       bool replaceValue = finding == options.end();
       if (!replaceValue)
       {
         try
         {
           us::any_cast<std::string>(finding->second);
         }
         catch (const us::BadAnyCastException& /*e*/)
         {
           replaceValue = true;
           //if we cannot cast in string the user has not made a selection yet
         }
       }
 
       if (sourceFinding != sourceOptions.end() && us::any_cast<std::string>(sourceFinding->second) != OPTION_NAME_MERGE_NO() && replaceValue)
       {
         options[newName] = sourceFinding->second;
       }
     }
   }
 
   std::string CESTDICOMManualReaderService::GetCESTMetaFilePath() const
   {
     auto dir = itksys::SystemTools::GetFilenamePath(this->GetInputLocation());
     std::string metafile = dir + "/" + "CEST_META.json";
     return metafile;
   }
 
   std::string CESTDICOMManualReaderService::GetTRECFilePath() const
   {
     auto dir = itksys::SystemTools::GetFilenamePath(this->GetInputLocation());
     std::string metafile = dir + "/" + "TREC.txt";
     return metafile;
   }
 
   std::string CESTDICOMManualReaderService::GetLISTFilePath() const
   {
     auto dir = itksys::SystemTools::GetFilenamePath(this->GetInputLocation());
     std::string metafile = dir + "/" + "LIST.txt";
     return metafile;
   }
 
 
   IFileIO::Options CESTDICOMManualReaderService::GetOptions() const
   {
     auto options = AbstractFileReader::GetOptions();
     if (!this->GetInputLocation().empty())
     {
       auto fileOptions = ExtractOptionsFromFile(this->GetCESTMetaFilePath());
 
       TransferOption(fileOptions, CEST_PROPERTY_NAME_B1Amplitude(), options, OPTION_NAME_B1());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_PULSEDURATION(), options, OPTION_NAME_PULSE());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_DutyCycle(), options, OPTION_NAME_DC());
       TransferMergeOption(fileOptions, META_FILE_OPTION_NAME_MERGE(), options, OPTION_NAME_MERGE());
     }
     return options;
   }
 
   us::Any CESTDICOMManualReaderService::GetOption(const std::string& name) const
   {
     this->GetOptions(); //ensure (default) options are set.
     return AbstractFileReader::GetOption(name);
   }
 
   DICOMFileReader::Pointer CESTDICOMManualReaderService::GetReader(const mitk::StringList& relevantFiles) const
   {
     auto selector = mitk::DICOMFileReaderSelector::New();
 
     const std::string mergeStrategy = this->GetOption(OPTION_NAME_MERGE()).ToString();
 
     if (mergeStrategy == OPTION_NAME_MERGE_YES())
     {
       auto r = ::us::GetModuleContext()->GetModule()->GetResource("cest_DKFZ.xml");
       selector->AddConfigFromResource(r);
     }
 
     selector->LoadBuiltIn3DnTConfigs();
     selector->SetInputFiles(relevantFiles);
 
     mitk::DICOMFileReader::Pointer reader = selector->GetFirstReaderWithMinimumNumberOfOutputImages();
     if (reader.IsNotNull())
     {
       //reset tag cache to ensure that additional tags of interest
       //will be regarded by the reader if set later on.
       reader->SetTagCache(nullptr);
     }
 
     return reader;
   }
 
   std::vector<itk::SmartPointer<BaseData>> CESTDICOMManualReaderService::Read()
   {
     const Options userOptions = this->GetOptions();
 
     const std::string mergeStrategy = userOptions.find(OPTION_NAME_MERGE())->second.ToString();
     this->SetOnlyRegardOwnSeries(mergeStrategy != OPTION_NAME_MERGE_YES());
 
     std::vector<BaseData::Pointer> result;
     std::vector<BaseData::Pointer> dicomResult = BaseDICOMReaderService::Read();
 
     const std::string normalizationStrategy = userOptions.find(OPTION_NAME_NORMALIZE())->second.ToString();
 
     for (const auto &item : dicomResult)
     {
       auto fileOptions = ExtractOptionsFromFile(this->GetCESTMetaFilePath());
       IFileIO::Options options;
       TransferOption(userOptions, OPTION_NAME_B1(), options, CEST_PROPERTY_NAME_B1Amplitude());
       TransferOption(userOptions, OPTION_NAME_PULSE(), options, CEST_PROPERTY_NAME_PULSEDURATION());
       TransferOption(userOptions, OPTION_NAME_DC(), options, CEST_PROPERTY_NAME_DutyCycle());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_B1Amplitude(), options, CEST_PROPERTY_NAME_B1Amplitude());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_PULSEDURATION(), options, CEST_PROPERTY_NAME_PULSEDURATION());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_DutyCycle(), options, CEST_PROPERTY_NAME_DutyCycle());
 
       TransferOption(fileOptions, CEST_PROPERTY_NAME_OFFSETS(), options, CEST_PROPERTY_NAME_OFFSETS());
       TransferOption(fileOptions, CEST_PROPERTY_NAME_TREC(), options, CEST_PROPERTY_NAME_TREC());
 
       auto trecValues = CustomTagParser::ReadListFromFile(this->GetTRECFilePath());
       auto offsetValues = CustomTagParser::ReadListFromFile(this->GetLISTFilePath());
 
       bool isCEST = !offsetValues.empty();
       bool isT1 = !trecValues.empty();
 
       if (!isCEST && !isT1)
       {//check if there are settings in the metafile
         auto finding = fileOptions.find(CEST_PROPERTY_NAME_OFFSETS());
         if (finding != fileOptions.end())
         {
           isCEST = true;
           offsetValues = finding->second.ToString();
         };
 
         finding = fileOptions.find(CEST_PROPERTY_NAME_TREC());
         if (finding != fileOptions.end())
         {
           isT1 = true;
           trecValues = finding->second.ToString();
         };
       }
 
       if (isCEST)
       {
         MITK_INFO << "CEST image detected due to LIST.txt or offset property in CEST_META.json";
         options[CEST_PROPERTY_NAME_OFFSETS()] = offsetValues;
       }
       else if (isT1)
       {
         MITK_INFO << "T1 image detected due to TREC.txt or trec property in CEST_META.json";
         options[CEST_PROPERTY_NAME_TREC()] = trecValues;
       }
       else
       {
         mitkThrow() << "Cannot load CEST/T1 file. No CEST offsets or T1 trec values specified. LIST.txt/TREC.txt or information in CEST_META.json is missing.";
       }
 
       for (const auto& option : options)
       {
         item->GetPropertyList()->SetStringProperty(option.first.c_str(), option.second.ToString().c_str());
       }
 
       auto freqProp = item->GetProperty(mitk::DICOMTagPathToPropertyName(DICOM_IMAGING_FREQUENCY_PATH()).c_str());
 
       if (freqProp.IsNull())
       {
         mitkThrow() << "Loaded image in invalid state. Does not contain the DICOM Imaging Frequency tag.";
       }
       SetCESTFrequencyMHz(item, mitk::ConvertDICOMStrToValue<double>(freqProp->GetValueAsString()));
 
       auto image = dynamic_cast<mitk::Image*>(item.GetPointer());
 
       if (isCEST)
       {
         try
         {
           auto offsets = ExtractCESTOffset(image);
         }
         catch (...)
         {
           mitkThrow() << "Cannot load CEST file. Number of CEST offsets do not equal the number of image time steps. Image time steps: " << image->GetTimeSteps() << "; offset values: " << offsetValues;
         }
       }
       else if (isT1)
       {
         try
         {
           auto t1s = ExtractCESTT1Time(image);
         }
         catch (...)
         {
           mitkThrow() << "Cannot load T1 file. Number of T1 times do not equal the number of image time steps. Image time steps: " << image->GetTimeSteps() << "; T1 values: " << trecValues;
         }
       }
 
       if (normalizationStrategy == OPTION_NAME_NORMALIZE_AUTOMATIC() && mitk::IsNotNormalizedCESTImage(image))
       {
         MITK_INFO << "Unnormalized CEST image was loaded and will be normalized automatically.";
         auto normalizationFilter = mitk::CESTImageNormalizationFilter::New();
         normalizationFilter->SetInput(image);
         normalizationFilter->Update();
         auto normalizedImage = normalizationFilter->GetOutput();
 
         auto nameProp = item->GetProperty("name");
         if (!nameProp)
         {
           mitkThrow() << "Cannot load CEST file. Property \"name\" is missing after BaseDICOMReaderService::Read().";
         }
         normalizedImage->SetProperty("name", mitk::StringProperty::New(nameProp->GetValueAsString() + "_normalized"));
         result.push_back(normalizedImage);
       }
       else
       {
         result.push_back(item);
       }
     }
 
     return result;
   }
 
   CESTDICOMManualReaderService *CESTDICOMManualReaderService::Clone() const
   {
     return new CESTDICOMManualReaderService(*this);
   }
 }
diff --git a/Modules/CEST/src/mitkCustomTagParser.cpp b/Modules/CEST/src/mitkCustomTagParser.cpp
index 49bbc08b59..ae68040759 100644
--- a/Modules/CEST/src/mitkCustomTagParser.cpp
+++ b/Modules/CEST/src/mitkCustomTagParser.cpp
@@ -1,855 +1,855 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkCustomTagParser.h"
 
 #include <mitkProperties.h>
 #include <mitkStringProperty.h>
 
 #include "mitkCESTPropertyHelper.h"
 #include "mitkIPropertyPersistence.h"
 
 #include "usGetModuleContext.h"
 #include "usModule.h"
 #include "usModuleContext.h"
 #include "usModuleResource.h"
 #include "usModuleResourceStream.h"
 
 #include <itksys/SystemTools.hxx>
 
 #include <Poco/Glob.h>
 
 #include <boost/algorithm/string.hpp>
-#include <boost/property_tree/json_parser.hpp>
-#include <boost/property_tree/ptree.hpp>
 #include <boost/tokenizer.hpp>
 
 #include <algorithm>
 #include <cstdint>
 #include <map>
 #include <string>
 #include <vector>
 
+#include <nlohmann/json.hpp>
+
+using namespace nlohmann;
+
 namespace
 {
   mitk::IPropertyPersistence *GetPersistenceService()
   {
     mitk::IPropertyPersistence *result = nullptr;
 
     std::vector<us::ServiceReference<mitk::IPropertyPersistence>> persRegisters =
       us::GetModuleContext()->GetServiceReferences<mitk::IPropertyPersistence>();
     if (!persRegisters.empty())
     {
       if (persRegisters.size() > 1)
       {
         MITK_WARN << "Multiple property description services found. Using just one.";
       }
       result = us::GetModuleContext()->GetService<mitk::IPropertyPersistence>(persRegisters.front());
     }
 
     return result;
   };
 }
 
 const std::string mitk::CustomTagParser::m_CESTPropertyPrefix = "CEST.";
 const std::string mitk::CustomTagParser::m_RevisionPropertyName = m_CESTPropertyPrefix + "Revision";
 const std::string mitk::CustomTagParser::m_JSONRevisionPropertyName = m_CESTPropertyPrefix + "revision_json";
 
-const std::string mitk::CustomTagParser::m_RevisionIndependentMapping =
-"\n"
-"  \"sProtConsistencyInfo.tSystemType\" : \"SysType\",\n"
-"  \"sProtConsistencyInfo.flNominalB0\" : \"NominalB0\",\n"
-"  \"sTXSPEC.asNucleusInfo[0].lFrequency\" : \"FREQ\",\n"
-"  \"sTXSPEC.asNucleusInfo[0].flReferenceAmplitude\" : \"RefAmp\",\n"
-"  \"alTR[0]\" : \"TR\",\n"
-"  \"alTE[0]\" : \"TE\",\n"
-"  \"lAverages\" : \"averages\",\n"
-"  \"lRepetitions\" : \"repetitions\",\n"
-"  \"adFlipAngleDegree[0]\" : \"ImageFlipAngle\",\n"
-"  \"lTotalScanTimeSec\" : \"TotalScanTime\",";
-const std::string mitk::CustomTagParser::m_DefaultJsonString =
-"{\n"
-"  \"default mapping, corresponds to revision 1416\" : \"revision_json\",\n"
-"  \"sWiPMemBlock.alFree[1]\" : \"AdvancedMode\",\n"
-"  \"sWiPMemBlock.alFree[2]\" : \"RecoveryMode\",\n"
-"  \"sWiPMemBlock.alFree[3]\" : \"DoubleIrrMode\",\n"
-"  \"sWiPMemBlock.alFree[4]\" : \"BinomMode\",\n"
-"  \"sWiPMemBlock.alFree[5]\" : \"MtMode\",\n"
-"  \"sWiPMemBlock.alFree[6]\" : \"PreparationType\",\n"
-"  \"sWiPMemBlock.alFree[7]\" : \"PulseType\",\n"
-"  \"sWiPMemBlock.alFree[8]\" : \"SamplingType\",\n"
-"  \"sWiPMemBlock.alFree[9]\" : \"SpoilingType\",\n"
-"  \"sWiPMemBlock.alFree[10]\" : \"measurements\",\n"
-"  \"sWiPMemBlock.alFree[11]\" : \"NumberOfPulses\",\n"
-"  \"sWiPMemBlock.alFree[12]\" : \"NumberOfLockingPulses\",\n"
-"  \"sWiPMemBlock.alFree[13]\" : \"PulseDuration\",\n"
-"  \"sWiPMemBlock.alFree[14]\" : \"DutyCycle\",\n"
-"  \"sWiPMemBlock.alFree[15]\" : \"RecoveryTime\",\n"
-"  \"sWiPMemBlock.alFree[16]\" : \"RecoveryTimeM0\",\n"
-"  \"sWiPMemBlock.alFree[17]\" : \"ReadoutDelay\",\n"
-"  \"sWiPMemBlock.alFree[18]\" : \"BinomDuration\",\n"
-"  \"sWiPMemBlock.alFree[19]\" : \"BinomDistance\",\n"
-"  \"sWiPMemBlock.alFree[20]\" : \"BinomNumberofPulses\",\n"
-"  \"sWiPMemBlock.alFree[21]\" : \"BinomPreRepetions\",\n"
-"  \"sWiPMemBlock.alFree[22]\" : \"BinomType\",\n"
-"  \"sWiPMemBlock.adFree[1]\" : \"Offset\",\n"
-"  \"sWiPMemBlock.adFree[2]\" : \"B1Amplitude\",\n"
-"  \"sWiPMemBlock.adFree[3]\" : \"AdiabaticPulseMu\",\n"
-"  \"sWiPMemBlock.adFree[4]\" : \"AdiabaticPulseBW\",\n"
-"  \"sWiPMemBlock.adFree[5]\" : \"AdiabaticPulseLength\",\n"
-"  \"sWiPMemBlock.adFree[6]\" : \"AdiabaticPulseAmp\",\n"
-"  \"sWiPMemBlock.adFree[7]\" : \"FermiSlope\",\n"
-"  \"sWiPMemBlock.adFree[8]\" : \"FermiFWHM\",\n"
-"  \"sWiPMemBlock.adFree[9]\" : \"DoubleIrrDuration\",\n"
-"  \"sWiPMemBlock.adFree[10]\" : \"DoubleIrrAmplitude\",\n"
-"  \"sWiPMemBlock.adFree[11]\" : \"DoubleIrrRepetitions\",\n"
-"  \"sWiPMemBlock.adFree[12]\" : \"DoubleIrrPreRepetitions\"\n"
-"}";
+const std::string mitk::CustomTagParser::m_RevisionIndependentMapping = R"(
+  "sProtConsistencyInfo.tSystemType" : "SysType",
+  "sProtConsistencyInfo.flNominalB0" : "NominalB0",
+  "sTXSPEC.asNucleusInfo[0].lFrequency" : "FREQ",
+  "sTXSPEC.asNucleusInfo[0].flReferenceAmplitude" : "RefAmp",
+  "alTR[0]" : "TR",
+  "alTE[0]" : "TE",
+  "lAverages" : "averages",
+  "lRepetitions" : "repetitions",
+  "adFlipAngleDegree[0]" : "ImageFlipAngle",
+  "lTotalScanTimeSec" : "TotalScanTime",
+)";
+const std::string mitk::CustomTagParser::m_DefaultJsonString = R"({
+  "default mapping, corresponds to revision 1416" : "revision_json",
+  "sWiPMemBlock.alFree[1]" : "AdvancedMode",
+  "sWiPMemBlock.alFree[2]" : "RecoveryMode",
+  "sWiPMemBlock.alFree[3]" : "DoubleIrrMode",
+  "sWiPMemBlock.alFree[4]" : "BinomMode",
+  "sWiPMemBlock.alFree[5]" : "MtMode",
+  "sWiPMemBlock.alFree[6]" : "PreparationType",
+  "sWiPMemBlock.alFree[7]" : "PulseType",
+  "sWiPMemBlock.alFree[8]" : "SamplingType",
+  "sWiPMemBlock.alFree[9]" : "SpoilingType",
+  "sWiPMemBlock.alFree[10]" : "measurements",
+  "sWiPMemBlock.alFree[11]" : "NumberOfPulses",
+  "sWiPMemBlock.alFree[12]" : "NumberOfLockingPulses",
+  "sWiPMemBlock.alFree[13]" : "PulseDuration",
+  "sWiPMemBlock.alFree[14]" : "DutyCycle",
+  "sWiPMemBlock.alFree[15]" : "RecoveryTime",
+  "sWiPMemBlock.alFree[16]" : "RecoveryTimeM0",
+  "sWiPMemBlock.alFree[17]" : "ReadoutDelay",
+  "sWiPMemBlock.alFree[18]" : "BinomDuration",
+  "sWiPMemBlock.alFree[19]" : "BinomDistance",
+  "sWiPMemBlock.alFree[20]" : "BinomNumberofPulses",
+  "sWiPMemBlock.alFree[21]" : "BinomPreRepetions",
+  "sWiPMemBlock.alFree[22]" : "BinomType",
+  "sWiPMemBlock.adFree[1]" : "Offset",
+  "sWiPMemBlock.adFree[2]" : "B1Amplitude",
+  "sWiPMemBlock.adFree[3]" : "AdiabaticPulseMu",
+  "sWiPMemBlock.adFree[4]" : "AdiabaticPulseBW",
+  "sWiPMemBlock.adFree[5]" : "AdiabaticPulseLength",
+  "sWiPMemBlock.adFree[6]" : "AdiabaticPulseAmp",
+  "sWiPMemBlock.adFree[7]" : "FermiSlope",
+  "sWiPMemBlock.adFree[8]" : "FermiFWHM",
+  "sWiPMemBlock.adFree[9]" : "DoubleIrrDuration",
+  "sWiPMemBlock.adFree[10]" : "DoubleIrrAmplitude",
+  "sWiPMemBlock.adFree[11]" : "DoubleIrrRepetitions",
+  "sWiPMemBlock.adFree[12]" : "DoubleIrrPreRepetitions"
+})";
 
 mitk::CustomTagParser::CustomTagParser(std::string relevantFile) : m_ClosestInternalRevision(""), m_ClosestExternalRevision("")
 {
   std::string pathToDirectory;
   std::string fileName;
   itksys::SystemTools::SplitProgramPath(relevantFile, pathToDirectory, fileName);
   m_DicomDataPath = pathToDirectory;
   m_ParseStrategy = "Automatic";
   m_RevisionMappingStrategy = "Fuzzy";
 }
 
 std::string mitk::CustomTagParser::ExtractRevision(std::string sequenceFileName)
 {
   //all rules are case insesitive. Thus we convert everything to lower case
   //in order to check everything only once.
   std::string cestPrefix = "cest";
   std::string cestPrefix2 = "_cest";
   std::string cestPrefix3 = "\\cest"; //this version covers the fact that the strings extracted
                                       //from the SIEMENS tag has an additional prefix that is seperated by backslash.
   std::string revisionPrefix = "_rev";
   std::transform(sequenceFileName.begin(), sequenceFileName.end(), sequenceFileName.begin(), ::tolower);
 
   bool isCEST = sequenceFileName.compare(0, cestPrefix.length(), cestPrefix) == 0;
   std::size_t foundPosition = 0;
 
   if (!isCEST)
   {
     foundPosition = sequenceFileName.find(cestPrefix2);
     isCEST = foundPosition != std::string::npos;
   }
 
   if (!isCEST)
   {
     foundPosition = sequenceFileName.find(cestPrefix3);
     isCEST = foundPosition != std::string::npos;
   }
 
   if (!isCEST)
   {
     mitkThrow() << "Invalid CEST sequence file name. No CEST prefix found. Could not extract revision.";
   }
 
   foundPosition = sequenceFileName.find(revisionPrefix, foundPosition);
   if (foundPosition == std::string::npos)
   {
     mitkThrow() << "Invalid CEST sequence file name. No revision prefix was found in CEST sequence file name. Could not extract revision.";
   }
 
   std::string revisionString = sequenceFileName.substr(foundPosition + revisionPrefix.length(), std::string::npos);
   std::size_t firstNoneNumber = revisionString.find_first_not_of("0123456789");
   if (firstNoneNumber != std::string::npos)
   {
     revisionString.erase(firstNoneNumber, std::string::npos);
   }
 
   return revisionString;
 }
 
 bool mitk::CustomTagParser::IsT1Sequence(std::string preparationType,
   std::string recoveryMode,
   std::string spoilingType,
   std::string revisionString)
 {
   bool isT1 = false;
 
   // if a forced parse strategy is set, use that one
   if ("T1" == m_ParseStrategy)
   {
     return true;
   }
   if ("CEST/WASABI" == m_ParseStrategy)
   {
     return false;
   }
 
   if (("T1Recovery" == preparationType) || ("T1Inversion" == preparationType))
   {
     isT1 = true;
   }
 
   // How to interpret the recoveryMode depends on the age of the sequence
   // older sequences use 0 = false and 1 = true, newer ones 1 = false and 2 = true.
   // A rough rule of thumb is to assume that if the SpoilingType is 0, then the first
   // convention is chosen, if it is 1, then the second applies. Otherwise
   // we assume revision 1485 and newer to follow the new convention.
   // This unfortunate heuristic is due to somewhat arbitrary CEST sequence implementations.
   if (!isT1)
   {
     std::string thisIsTrue = "1";
     std::string thisIsFalse = "0";
     if ("0" == spoilingType)
     {
       thisIsFalse = "0";
       thisIsTrue = "1";
     }
     else if ("1" == spoilingType)
     {
       thisIsFalse = "1";
       thisIsTrue = "2";
     }
     else
     {
       int revisionNrWeAssumeToBeDifferenciating = 1485;
       if (std::stoi(revisionString) - revisionNrWeAssumeToBeDifferenciating < 0)
       {
         thisIsFalse = "0";
         thisIsTrue = "1";
       }
       else
       {
         thisIsFalse = "1";
         thisIsTrue = "2";
       }
     }
 
     if (thisIsFalse == recoveryMode)
     {
       isT1 = false;
     }
     else if (thisIsTrue == recoveryMode)
     {
       isT1 = true;
     }
 
   }
 
   return isT1;
 }
 
 mitk::PropertyList::Pointer mitk::CustomTagParser::ParseDicomPropertyString(std::string dicomPropertyString)
 {
   auto results = mitk::PropertyList::New();
   if ("" == dicomPropertyString)
   {
     //MITK_ERROR << "Could not parse empty custom dicom string";
     return results;
   }
 
   auto comp = [](const std::string& s1, const std::string& s2)
   {
     return boost::algorithm::lexicographical_compare(s1, s2, boost::algorithm::is_iless());
   };
 
   std::map<std::string, std::string, decltype(comp)> privateParameters(comp);
 
   // The Siemens private tag contains information like "43\52\23\34".
   // We jump over each "\" and convert the number;
   std::string bytes;
 
   {
     const std::size_t SUBSTR_LENGTH = 2;
     const std::size_t INPUT_LENGTH = dicomPropertyString.length();
 
     if (INPUT_LENGTH < SUBSTR_LENGTH)
       return results;
 
     const std::size_t MAX_INPUT_OFFSET = INPUT_LENGTH - SUBSTR_LENGTH;
     bytes.reserve(INPUT_LENGTH / 3 + 1);
 
     try
     {
       for (std::size_t i = 0; i <= MAX_INPUT_OFFSET; i += 3)
       {
         std::string byte_string = dicomPropertyString.substr(i, SUBSTR_LENGTH);
         int byte = static_cast<std::string::value_type>(std::stoi(byte_string.c_str(), nullptr, 16));
         bytes.push_back(byte);
       }
     }
     catch (const std::invalid_argument&) // std::stoi() could not perform conversion
     {
       return results;
     }
   }
 
   // extract parameter list
   std::string parameterListString;
 
   {
     const std::string ASCCONV_MARKER = "###";
     const std::string ASCCONV_BEGIN = "### ASCCONV BEGIN";
     const std::string ASCCONV_END = "### ASCCONV END";
 
     auto ascconvBeginPos = bytes.find(ASCCONV_BEGIN);
     if (std::string::npos == ascconvBeginPos)
       return results;
     ascconvBeginPos += ASCCONV_BEGIN.length();
 
     ascconvBeginPos = bytes.find(ASCCONV_MARKER, ascconvBeginPos);
     if (std::string::npos == ascconvBeginPos)
       return results;
     ascconvBeginPos += ASCCONV_MARKER.length(); // closing "###"
 
     auto ascconvEndPos = bytes.find(ASCCONV_END, ascconvBeginPos);
     if (std::string::npos == ascconvEndPos)
       return results;
 
     auto count = ascconvEndPos - ascconvBeginPos;
 
     parameterListString = bytes.substr(ascconvBeginPos, count);
   }
 
   boost::replace_all(parameterListString, "\r\n", "\n");
   boost::replace_all(parameterListString, "\t", "");
   boost::char_separator<char> newlineSeparator("\n");
   boost::tokenizer<boost::char_separator<char>> parameters(parameterListString, newlineSeparator);
   for (const auto &parameter : parameters)
   {
     std::vector<std::string> parts;
     boost::split(parts, parameter, boost::is_any_of("="));
 
     if (parts.size() == 2)
     {
       parts[0].erase(std::remove(parts[0].begin(), parts[0].end(), ' '), parts[0].end());
       parts[1].erase(parts[1].begin(), parts[1].begin() + 1); // first character is a space
       privateParameters[parts[0]] = parts[1];
     }
   }
 
   std::string revisionString = "";
 
   try
   {
     revisionString = ExtractRevision(privateParameters["tSequenceFileName"]);
   }
   catch (const std::exception &e)
   {
     MITK_ERROR << "Cannot deduce revision information. Reason: "<< e.what();
     return results;
   }
 
   results->SetProperty(m_RevisionPropertyName, mitk::StringProperty::New(revisionString));
 
   std::string jsonString = GetRevisionAppropriateJSONString(revisionString);
 
-  boost::property_tree::ptree root;
-  std::istringstream jsonStream(jsonString);
+  json root;
   try
   {
-    boost::property_tree::read_json(jsonStream, root);
+    root = json::parse(jsonString);
   }
-  catch (const boost::property_tree::json_parser_error &e)
+  catch (const json::exception &e)
   {
     mitkThrow() << "Could not parse json file. Error was:\n" << e.what();
   }
 
-  for (const auto &it : root)
+  for (const auto &it : root.items())
   {
-    if (it.second.empty())
+    if (it.value().is_string())
     {
-      std::string propertyName = m_CESTPropertyPrefix + it.second.data();
+      auto propertyName = m_CESTPropertyPrefix + it.value().get<std::string>();
       if (m_JSONRevisionPropertyName == propertyName)
       {
-        results->SetProperty(propertyName, mitk::StringProperty::New(it.first));
+        results->SetProperty(propertyName, mitk::StringProperty::New(it.key()));
       }
       else
       {
-        results->SetProperty(propertyName, mitk::StringProperty::New(privateParameters[it.first]));
+        results->SetProperty(propertyName, mitk::StringProperty::New(privateParameters[it.key()]));
       }
     }
     else
     {
       MITK_ERROR << "Currently no support for nested dicom tag descriptors in json file.";
     }
   }
 
   std::string offset = "";
   std::string measurements = "";
   results->GetStringProperty("CEST.Offset", offset);
   results->GetStringProperty("CEST.measurements", measurements);
 
   if (measurements.empty())
   {
     std::string stringRepetitions = "";
     results->GetStringProperty("CEST.repetitions", stringRepetitions);
 
     std::string stringAverages = "";
     results->GetStringProperty("CEST.averages", stringAverages);
 
     const auto ERROR_STRING = "Could not find measurements, fallback assumption of repetitions + averages could not be determined either.";
 
     if (!stringRepetitions.empty() && !stringAverages.empty())
     {
       std::stringstream measurementStream;
 
       try
       {
         measurementStream << std::stoi(stringRepetitions) + std::stoi(stringAverages);
         measurements = measurementStream.str();
         MITK_INFO << "Could not find measurements, assuming repetitions + averages. That is: " << measurements;
       }
       catch (const std::invalid_argument&)
       {
         MITK_ERROR << ERROR_STRING;
       }
     }
     else
     {
       MITK_WARN << ERROR_STRING;
     }
   }
 
   std::string preparationType = "";
   std::string recoveryMode = "";
   std::string spoilingType = "";
   results->GetStringProperty(CEST_PROPERTY_NAME_PREPERATIONTYPE().c_str(), preparationType);
   results->GetStringProperty(CEST_PROPERTY_NAME_RECOVERYMODE().c_str(), recoveryMode);
   results->GetStringProperty(CEST_PROPERTY_NAME_SPOILINGTYPE().c_str(), spoilingType);
 
   if (this->IsT1Sequence(preparationType, recoveryMode, spoilingType, revisionString))
   {
     MITK_INFO << "Parsed as T1 image";
 
     std::stringstream trecStream;
 
     std::string trecPath = m_DicomDataPath + "/TREC.txt";
     auto trec = ReadListFromFile(trecPath);
 
     if(trec.empty())
     {
       MITK_WARN << "Assumed T1, but could not load TREC at " << trecPath;
     }
 
     results->SetStringProperty(CEST_PROPERTY_NAME_TREC().c_str(), trec.c_str());
   }
   else
   {
     MITK_INFO << "Parsed as CEST or WASABI image";
     std::string sampling = "";
     bool hasSamplingInformation = results->GetStringProperty("CEST.SamplingType", sampling);
     if (hasSamplingInformation)
     {
       std::string offsets = GetOffsetString(sampling, offset, measurements);
       results->SetStringProperty(CEST_PROPERTY_NAME_OFFSETS().c_str(), offsets.c_str());
     }
     else
     {
       MITK_WARN << "Could not determine sampling type.";
     }
   }
 
 
   //persist all properties
   mitk::IPropertyPersistence *persSrv = GetPersistenceService();
   if (persSrv)
   {
     auto propertyMap = results->GetMap();
     for (auto const &prop : *propertyMap)
     {
       PropertyPersistenceInfo::Pointer info = PropertyPersistenceInfo::New();
       std::string key = prop.first;
       std::replace(key.begin(), key.end(), '.', '_');
       info->SetNameAndKey(prop.first, key);
 
       persSrv->AddInfo(info);
     }
   }
 
   return results;
 }
 
 std::string mitk::CustomTagParser::ReadListFromFile(const std::string& filePath)
 {
   std::stringstream listStream;
   std::ifstream list(filePath.c_str());
   list.imbue(std::locale("C"));
 
   if (list.good())
   {
     std::string currentValue;
     while (std::getline(list, currentValue))
     {
       listStream << currentValue << " ";
     }
   }
   return listStream.str();
 }
 
 mitk::PropertyList::Pointer mitk::CustomTagParser::ParseDicomProperty(mitk::TemporoSpatialStringProperty *dicomProperty)
 {
   if (!dicomProperty)
   {
     MITK_ERROR << "DICOM property empty";
   }
 
   auto results = mitk::PropertyList::New();
 
   if (dicomProperty)
   {
     results = ParseDicomPropertyString(dicomProperty->GetValue());
   }
 
   return results;
 }
 
 std::vector<int> mitk::CustomTagParser::GetInternalRevisions()
 {
   const std::vector<us::ModuleResource> configs =
     us::GetModuleContext()->GetModule()->FindResources("/", "*.json", false);
 
   std::vector<int> availableRevisionsVector;
 
   for (const auto& resource : configs)
   {
     availableRevisionsVector.push_back(std::stoi(resource.GetBaseName()));
   }
 
   return availableRevisionsVector;
 }
 
 std::vector<int> mitk::CustomTagParser::GetExternalRevisions()
 {
   std::string stringToJSONDirectory = GetExternalJSONDirectory();
 
   std::string prospectiveJsonsPath = stringToJSONDirectory + "/*.json";
 
   std::set<std::string> JsonFiles;
   Poco::Glob::glob(prospectiveJsonsPath, JsonFiles, Poco::Glob::GLOB_CASELESS);
 
   std::vector<int> availableRevisionsVector;
 
   for (const auto& jsonpath : JsonFiles)
   {
     std::string jsonDir;
     std::string jsonName;
     itksys::SystemTools::SplitProgramPath(jsonpath, jsonDir, jsonName);
     std::string revision = itksys::SystemTools::GetFilenameWithoutExtension(jsonName);
 
     // disregard jsons which contain letters in their name
     bool onlyNumbers = (revision.find_first_not_of("0123456789") == std::string::npos);
 
     if(onlyNumbers)
     {
       availableRevisionsVector.push_back(std::stoi(revision));
     }
   }
 
   return availableRevisionsVector;
 }
 
 std::string mitk::CustomTagParser::GetClosestLowerRevision(std::string revisionString, std::vector<int> availableRevisionsVector)
 {
 
   // descending order
   std::sort(availableRevisionsVector.begin(), availableRevisionsVector.end(), std::greater<>());
 
   int revision = std::stoi(revisionString);
 
   int index = 0;
   int numberOfRevisions = availableRevisionsVector.size();
 
   while (index < numberOfRevisions)
   {
     // current mapping still has a higher revision number
     if ((availableRevisionsVector[index] - revision) > 0)
     {
       ++index;
     }
     else
     {
       break;
     }
   }
 
   if (index < numberOfRevisions)
   {
     std::stringstream foundRevisionStream;
     foundRevisionStream << availableRevisionsVector[index];
 
     return foundRevisionStream.str();
   }
 
   return "";
 }
 
 void mitk::CustomTagParser::GetClosestLowerRevision(std::string revisionString)
 {
   m_ClosestInternalRevision = GetClosestLowerRevision(revisionString, GetInternalRevisions());
   m_ClosestExternalRevision = GetClosestLowerRevision(revisionString, GetExternalRevisions());
 
   if ("Strict" == m_RevisionMappingStrategy && !((0 == m_ClosestInternalRevision.compare(revisionString)) ||
                                                  (0 == m_ClosestExternalRevision.compare(revisionString))))
   { // strict revision mapping and neither revision does match the dicom meta data
     std::stringstream errorMessageStream;
     errorMessageStream << "\nCould not parse dicom data in strict mode, data revision " << revisionString
       << " has no known matching parameter mapping. To use the closest known older parameter mapping select the "
       << "\"Fuzzy\" revision mapping option when loading the data.\n"
       << "\nCurrently known revision mappings are:\n  Precompiled:";
     for (const auto revision : GetInternalRevisions())
     {
       errorMessageStream << " " << revision;
     }
     errorMessageStream << "\n  External:";
     for (const auto revision : GetExternalRevisions())
     {
       errorMessageStream << " " << revision;
     }
     errorMessageStream << "\n\nExternal revision mapping descriptions should be located at\n\n";
     std::string stringToJSONDirectory = GetExternalJSONDirectory();
     errorMessageStream << stringToJSONDirectory;
 
     errorMessageStream << "\n\nTo provide an external mapping for this revision create a " << revisionString
                        << ".json there. You might need to create the directory first.";
 
     mitkThrow() << errorMessageStream.str();
   }
 }
 
 std::string mitk::CustomTagParser::GetRevisionAppropriateJSONString(std::string revisionString)
 {
   std::string returnValue = "";
 
   if ("" == revisionString)
   {
     MITK_WARN << "Could not extract revision";
   }
   else
   {
     GetClosestLowerRevision(revisionString);
 
     bool useExternal = false;
     bool useInternal = false;
 
     if ("" != m_ClosestExternalRevision)
     {
       useExternal = true;
     }
     if ("" != m_ClosestInternalRevision)
     {
       useInternal = true;
     }
 
     if (useExternal && useInternal)
     {
       if (std::stoi(m_ClosestInternalRevision) > std::stoi(m_ClosestExternalRevision))
       {
         useExternal = false;
       }
     }
 
     if (useExternal)
     {
       std::string stringToJSONDirectory = GetExternalJSONDirectory();
 
       std::string prospectiveJsonPath = stringToJSONDirectory + "/" + m_ClosestExternalRevision + ".json";
 
       std::ifstream externalJSON(prospectiveJsonPath.c_str());
 
       if (externalJSON.good())
       {
         MITK_INFO << "Found external json for CEST parameters at " << prospectiveJsonPath;
 
         std::stringstream buffer;
         buffer << externalJSON.rdbuf();
 
         returnValue = buffer.str();
 
         useInternal = false;
       }
     }
 
     if (useInternal)
     {
       std::string filename = m_ClosestInternalRevision + ".json";
       us::ModuleResource jsonResource = us::GetModuleContext()->GetModule()->GetResource(filename);
 
       if (jsonResource.IsValid() && jsonResource.IsFile())
       {
         MITK_INFO << "Found no external json for CEST parameters. Closest internal mapping is for revision "
                   << m_ClosestInternalRevision;
         us::ModuleResourceStream jsonStream(jsonResource);
         std::stringstream buffer;
         buffer << jsonStream.rdbuf();
         returnValue = buffer.str();
       }
     }
   }
 
   if ("" == returnValue)
   {
     MITK_WARN << "Could not identify parameter mapping for the given revision " << revisionString
               << ", using default mapping.";
     returnValue = m_DefaultJsonString;
   }
 
   // inject the revision independent mapping before the first newline
   {
     returnValue.insert(returnValue.find("\n"), m_RevisionIndependentMapping);
   }
 
   return returnValue;
 }
 
 std::string mitk::CustomTagParser::GetOffsetString(std::string samplingType, std::string offset, std::string measurements)
 {
   std::stringstream results;
   results.imbue(std::locale("C"));
 
   std::string normalizationIndicatingOffset = "-300";
 
   double offsetDouble = 0.0;
   int measurementsInt = 0;
 
   bool validOffset = false;
   bool validMeasurements = false;
 
   if ("" != offset)
   {
     validOffset = true;
     offsetDouble = std::stod(offset);
   }
   if ("" != measurements)
   {
     validMeasurements = true;
     measurementsInt = std::stoi(measurements);
   }
 
   std::vector<double> offsetVector;
 
   if (validOffset && validMeasurements)
   {
     for (int step = 0; step < measurementsInt -1; ++step)
     {
       double currentOffset = -offsetDouble + 2 * step * offsetDouble / (measurementsInt - 2.0);
       offsetVector.push_back(currentOffset);
     }
   }
   else
   {
     MITK_WARN << "Invalid offset or measurements, offset calculation will only work for list sampling type.";
   }
 
   if (samplingType == "1" || samplingType == "Regular")
   {
     if (validOffset && validMeasurements)
     {
       results << normalizationIndicatingOffset << " ";
       for (const auto& entry : offsetVector)
       {
         results << entry << " ";
       }
     }
   }
   else if (samplingType == "2" || samplingType == "Alternating")
   {
     if (validOffset && validMeasurements)
     {
       results << normalizationIndicatingOffset << " ";
       for (auto& entry : offsetVector)
       {
         entry = std::abs(entry);
       }
 
       std::sort(offsetVector.begin(), offsetVector.end(), std::greater<>());
 
       for (unsigned int index = 0; index < offsetVector.size(); ++index)
       {
         offsetVector[index] = std::pow(-1, index) * offsetVector[index];
       }
 
       for (auto& entry : offsetVector)
       {
         results << entry << " ";
       }
     }
   }
   else if (samplingType == "3" || samplingType == "List")
   {
     std::string listPath = m_DicomDataPath + "/LIST.txt";
 
     auto values = ReadListFromFile(listPath);
 
     if (!values.empty())
     {
       results << values;
     }
     else
     {
       MITK_ERROR << "Could not load list at " << listPath;
     }
   }
   else if (samplingType == "4" || samplingType == "SingleOffset")
   {
     if (validOffset && validMeasurements)
     {
       results << normalizationIndicatingOffset << " ";
       for (int step = 0; step < measurementsInt - 1; ++step)
       {
         results << offsetDouble << " ";
       }
     }
   }
   else
   {
     MITK_WARN << "Encountered unknown sampling type.";
   }
 
   std::string resultString = results.str();
   // replace multiple spaces by a single space
   std::string::iterator newEnditerator =
     std::unique(resultString.begin(), resultString.end(),
       [=](char lhs, char rhs) { return (lhs == rhs) && (lhs == ' '); }
   );
   resultString.erase(newEnditerator, resultString.end());
 
   if ((resultString.length() > 0) && (resultString.at(resultString.length() - 1) == ' '))
   {
     resultString.erase(resultString.end() - 1, resultString.end());
   }
 
   if ((resultString.length() > 0) && (resultString.at(0) == ' '))
   {
     resultString.erase(resultString.begin(), ++(resultString.begin()));
   }
 
   return resultString;
 }
 
 void mitk::CustomTagParser::SetParseStrategy(std::string parseStrategy)
 {
   m_ParseStrategy = parseStrategy;
 }
 
 void mitk::CustomTagParser::SetRevisionMappingStrategy(std::string revisionMappingStrategy)
 {
   m_RevisionMappingStrategy = revisionMappingStrategy;
 }
 
 std::string mitk::CustomTagParser::GetExternalJSONDirectory()
 {
   std::string moduleLocation = us::GetModuleContext()->GetModule()->GetLocation();
   std::string stringToModule;
   std::string libraryName;
   itksys::SystemTools::SplitProgramPath(moduleLocation, stringToModule, libraryName);
 
   std::stringstream jsonDirectory;
   jsonDirectory << stringToModule << "/CESTRevisionMapping";
 
   return jsonDirectory.str();
 }
diff --git a/Modules/Classification/CLMiniApps/CLPlanarFigureToNrrd.cpp b/Modules/Classification/CLMiniApps/CLPlanarFigureToNrrd.cpp
index 488d45e581..da36d996ee 100644
--- a/Modules/Classification/CLMiniApps/CLPlanarFigureToNrrd.cpp
+++ b/Modules/Classification/CLMiniApps/CLPlanarFigureToNrrd.cpp
@@ -1,140 +1,140 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #ifndef mitkCLPolyToNrrd_cpp
 #define mitkCLPolyToNrrd_cpp
 
 #include "time.h"
 #include <sstream>
 
 #include <mitkIOUtil.h>
 
 #include "mitkCommandLineParser.h"
 #include <mitkPlanarFigureMaskGenerator.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <mitkImageAccessByItk.h>
 
 
 typedef itk::Image< double, 3 >                 FloatImageType;
 typedef itk::Image< unsigned char, 3 >          MaskImageType;
 
 struct MaskParameter
 {
-  mitk::Image::Pointer mask;
+  mitk::Image::ConstPointer mask;
   unsigned int axis;
   unsigned int slice;
 };
 
 template < typename TPixel, unsigned int VImageDimension >
 void CreateNewMask(const itk::Image< TPixel, VImageDimension > *image, MaskParameter param, mitk::Image::Pointer &output)
 {
   int transform[3][2];
   transform[0][0] = 1; transform[0][1] = 2;
   transform[1][0] = 0; transform[1][1] = 2;
   transform[2][0] = 0; transform[2][1] = 1;
 
   typedef itk::Image<unsigned short, VImageDimension> MaskType;
   typedef itk::Image<unsigned short, 2> Mask2DType;
   typename Mask2DType::Pointer mask = Mask2DType::New();
   mitk::CastToItkImage(param.mask, mask);
 
 
   typename MaskType::Pointer mask3D = MaskType::New();
   mask3D->SetRegions(image->GetLargestPossibleRegion());
   mask3D->SetSpacing(image->GetSpacing());
   mask3D->SetOrigin(image->GetOrigin());
   mask3D->Allocate();
 
   itk::ImageRegionIteratorWithIndex<MaskType> iter(mask3D, mask3D->GetLargestPossibleRegion());
   while (!iter.IsAtEnd())
   {
     auto index = iter.GetIndex();
     iter.Set(0);
     if (index[param.axis] == param.slice)
     {
       Mask2DType::IndexType index2D;
       index2D[0] = index[transform[param.axis][0]];
       index2D[1] = index[transform[param.axis][1]];
       auto pixel = mask->GetPixel(index2D);
       iter.Set(pixel);
     }
     ++iter;
   }
 
   mitk::CastToMitkImage(mask3D, output);
 
 }
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   // required params
   parser.addArgument("planar", "p", mitkCommandLineParser::Directory, "Input Polydata", "Path to the input VTK polydata", us::Any(), false, false, false, mitkCommandLineParser::Input);
   parser.addArgument("image", "i", mitkCommandLineParser::Directory, "Input Image", "Image which defines the dimensions of the Segmentation", us::Any(), false, false, false, mitkCommandLineParser::Output);
   parser.addArgument("output", "o", mitkCommandLineParser::File, "Output file", "Output file. ", us::Any(), false, false, false, mitkCommandLineParser::Input);
   // Miniapp Infos
   parser.setCategory("Classification Tools");
   parser.setTitle("Planar Data to Nrrd Segmentation");
   parser.setDescription("Creates a Nrrd segmentation based on a 2d-vtk polydata.");
   parser.setContributor("German Cancer Research Center (DKFZ)");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size()==0)
   {
     return EXIT_FAILURE;
   }
   if ( parsedArgs.count("help") || parsedArgs.count("h"))
   {
     return EXIT_SUCCESS;
   }
 
   try
   {
     mitk::BaseData::Pointer data = mitk::IOUtil::Load(parsedArgs["planar"].ToString())[0];
     mitk::PlanarFigure::Pointer planar = dynamic_cast<mitk::PlanarFigure*>(data.GetPointer());
 
     mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(parsedArgs["image"].ToString());
 
     mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
     pfMaskGen->SetPlanarFigure(planar);
     pfMaskGen->SetTimeStep(0);
     pfMaskGen->SetInputImage(image.GetPointer());
 
-    mitk::Image::Pointer mask = pfMaskGen->GetMask();
+    mitk::Image::ConstPointer mask = pfMaskGen->GetMask();
     unsigned int axis = pfMaskGen->GetPlanarFigureAxis();
     unsigned int slice = pfMaskGen->GetPlanarFigureSlice();
 
     //itk::Image<unsigned short, 3>::IndexType index;
     mitk::Image::Pointer fullMask;
     MaskParameter param;
     param.slice = slice;
     param.axis = axis;
     param.mask = mask;
     AccessByItk_2(image, CreateNewMask, param, fullMask);
 
     std::string saveAs = parsedArgs["output"].ToString();
     MITK_INFO << "Save as: " << saveAs;
-    mitk::IOUtil::Save(pfMaskGen->GetMask(), saveAs);
+    mitk::IOUtil::Save(mask, saveAs);
     mitk::IOUtil::Save(fullMask, saveAs);
 
     return 0;
   }
   catch (...)
   {
     return EXIT_FAILURE;
   }
 }
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/mitkCLUtil.h b/Modules/Classification/CLUtilities/include/mitkCLUtil.h
index 6202e9197b..7241b2d4af 100644
--- a/Modules/Classification/CLUtilities/include/mitkCLUtil.h
+++ b/Modules/Classification/CLUtilities/include/mitkCLUtil.h
@@ -1,581 +1,581 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkCLUtil_h
 #define mitkCLUtil_h
 
 #include <Eigen/Dense>
 #include <MitkCLUtilitiesExports.h>
 #include <itkImageRegionIterator.h>
 
 
 #include <mitkImage.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 
 #include <itkConnectedComponentImageFilter.h>
 namespace mitk
 {
 
 class MITKCLUTILITIES_EXPORT CLUtil
 {
 public:
   ///
   /// \brief The MorphologicalDimensions enum
   ///
   enum MorphologicalDimensions
   {
-    Axial,Coronal,Sagital,All
+    Axial,Coronal,Sagittal,All
   };
 
   ///
   /// \brief CreateCheckerBoardPredictionMask
   /// \param image
   /// \param outimage
   ///
   static void CreateCheckerboardMask(mitk::Image::Pointer image, mitk::Image::Pointer & outimage);
 
   ///
   /// \brief InterpolateCreateCheckerboardPrediction
   /// \param checkerboard_prediction
   /// \param checkerboard_mask
   /// \param outimage
   ///
   static void InterpolateCheckerboardPrediction(mitk::Image::Pointer checkerboard_prediction, mitk::Image::Pointer & checkerboard_mask, mitk::Image::Pointer & outimage);
 
   ///
   /// \brief CountVoxel
   /// \param image
   /// \param map
   ///
   static void CountVoxel(mitk::Image::Pointer image, std::map<unsigned int, unsigned int> & map);
 
   ///
   /// \brief CountVoxel
   /// \param image
   /// \param label
   /// \param count
   ///
   static void CountVoxel(mitk::Image::Pointer image, unsigned int label, unsigned int & count);
 
   ///
   /// \brief CountVoxel
   /// \param image
   /// \param count
   ///
   static void CountVoxel(mitk::Image::Pointer image, unsigned int & count);
 
   ///
   /// \brief SumVoxelForLabel
   /// \param image
   /// \param source
   /// \param label
   /// \param val
   ///
   static void SumVoxelForLabel(mitk::Image::Pointer image, const mitk::Image::Pointer & source , unsigned int label, double & val );
 
   ///
   /// \brief SqSumVoxelForLabel
   /// \param image
   /// \param source
   /// \param label
   /// \param val
   ///
   static void SqSumVoxelForLabel(mitk::Image::Pointer image, const mitk::Image::Pointer & source, unsigned int label, double & val );
 
   ///
   /// \brief LogicalAndImages
   /// \param image1
   /// \param image2
   /// \param outimage
   ///
   static void LogicalAndImages(const Image::Pointer &image1, const Image::Pointer &image2, Image::Pointer &outimage);
 
 
   ///
   /// \brief GaussianFilter
   /// \param image
   /// \param smoothed
   /// \param sigma
   ///
   static void GaussianFilter(mitk::Image::Pointer image, mitk::Image::Pointer & smoothed ,double sigma);
 
   ///
   /// \brief SubtractGaussianFilter
   /// \param image
   /// \param smoothed (Result is sigma1-sigma2)
   /// \param sigma1
   /// \param sigma2
   ///
   static void DifferenceOfGaussianFilter(mitk::Image::Pointer image, mitk::Image::Pointer & smoothed, double sigma1, double sigma2);
 
   ///
   /// \brief Laplacian of Gaussian
   /// \param image
   /// \param smoothed (Result is sigma1-sigma2)
   /// \param sigma1
   ///
   static void LaplacianOfGaussianFilter(mitk::Image::Pointer image, mitk::Image::Pointer & smoothed, double sigma1);
 
   ///
   /// \brief SubtractGaussianFilter
   /// \param image
   /// \param out
   /// \param sigma
   ///
   static void HessianOfGaussianFilter(mitk::Image::Pointer image, std::vector<mitk::Image::Pointer> &out, double sigma);
 
   ///
   /// \brief Local Histogram
   /// \param image
   /// \param out
   /// \param Bins
   /// \param NeighbourhoodSize
   ///
   static void LocalHistogram(mitk::Image::Pointer image, std::vector<mitk::Image::Pointer> &out, int Bins, int NeighbourhoodSize);
 
   ///
   /// \brief transform
   /// \param matrix
   /// \param mask
   ///
   template<typename TMatrixElementType>
   static mitk::Image::Pointer Transform(const Eigen::Matrix<TMatrixElementType, Eigen::Dynamic, Eigen::Dynamic> & matrix, const mitk::Image::Pointer & mask)
   {
     itk::Image<unsigned int, 3>::Pointer itkMask;
     mitk::CastToItkImage(mask,itkMask);
 
     typename itk::Image<TMatrixElementType, 3>::Pointer itk_img = itk::Image<TMatrixElementType, 3>::New();
     itk_img->SetRegions(itkMask->GetLargestPossibleRegion());
     itk_img->SetOrigin(itkMask->GetOrigin());
     itk_img->SetSpacing(itkMask->GetSpacing());
     itk_img->SetDirection(itkMask->GetDirection());
     itk_img->Allocate();
 
 
     unsigned int n_numSamples = 0;
     mitk::CLUtil::CountVoxel(mask,n_numSamples);
 
     if(n_numSamples != matrix.rows())
       MITK_ERROR << "Number of samples in matrix and number of points under the masks is not the same!";
 
     auto mit = itk::ImageRegionConstIterator<itk::Image<unsigned int, 3> >(itkMask, itkMask->GetLargestPossibleRegion());
     auto oit = itk::ImageRegionIterator<itk::Image<TMatrixElementType, 3> >(itk_img, itk_img->GetLargestPossibleRegion());
 
     unsigned int current_row = 0;
     while(!mit.IsAtEnd())
     {
       if(mit.Value() > 0)
         oit.Set(matrix(current_row++,0));
       else
         oit.Set(0.0);
       ++mit;
       ++oit;
     }
 
     mitk::Image::Pointer out_img = mitk::Image::New();
     mitk::GrabItkImageMemory(itk_img,out_img);
     return out_img;
   }
   ///
   /// \brief TransformImageToMatrix
   /// \param img
   /// \param mask
   ///
   template<typename TMatrixElementType>
   static Eigen::Matrix<TMatrixElementType, Eigen::Dynamic, Eigen::Dynamic> Transform(const mitk::Image::Pointer & img, const mitk::Image::Pointer & mask)
   {
     itk::Image<unsigned int, 3>::Pointer current_mask;
     mitk::CastToItkImage(mask,current_mask);
 
     unsigned int n_numSamples = 0;
     mitk::CLUtil::CountVoxel(mask,n_numSamples);
 
     typename itk::Image<TMatrixElementType, 3>::Pointer current_img;
     mitk::CastToItkImage(img,current_img);
 
     Eigen::Matrix<TMatrixElementType, Eigen::Dynamic, Eigen::Dynamic> out_matrix(n_numSamples,1);
 
     auto mit = itk::ImageRegionConstIterator<itk::Image<unsigned int, 3> >(current_mask, current_mask->GetLargestPossibleRegion());
     auto iit = itk::ImageRegionConstIterator<itk::Image<TMatrixElementType, 3> >(current_img,current_img->GetLargestPossibleRegion());
     unsigned int current_row = 0;
     while (!mit.IsAtEnd()) {
       if(mit.Value() > 0)
         out_matrix(current_row++) = iit.Value();
       ++mit;
       ++iit;
     }
 
     return out_matrix;
   }
 
   ///
   /// \brief DilateBinary
   /// \param sourceImage
   /// \param resultImage
   /// \param radius Size of the StructuringElement
   /// \param d
   ///
   static void DilateBinary(mitk::Image::Pointer & sourceImage, mitk::Image::Pointer& resultImage, int radius , MorphologicalDimensions d);
 
   ///
   /// \brief ErodeBinary
   /// \param sourceImage
   /// \param resultImage
   /// \param radius Size of the StructuringElement
   /// \param d
   ///
   static void ErodeBinary(mitk::Image::Pointer & sourceImage, mitk::Image::Pointer& resultImage, int radius, MorphologicalDimensions d);
 
   ///
   /// \brief ClosingBinary
   /// \param sourceImage
   /// \param resultImage
   /// \param radius Size of the StructuringElement
   /// \param d
   ///
   static void ClosingBinary(mitk::Image::Pointer & sourceImage, mitk::Image::Pointer& resultImage, int radius, MorphologicalDimensions d);
 
 
   ///
   /// \brief MergeLabels
   /// \param img
   /// \param map merge instruction where each map entry defines a mapping instruction. Key \c \<sourcelabel\> - Value \c \<targetlabel\>
   ///
   static void MergeLabels(mitk::Image::Pointer & img, const std::map<unsigned int, unsigned int> & map);
 
   ///
   /// \brief ConnectedComponentsImage
   /// \param image
   /// \param mask
   /// \param outimage
   /// \param num_components Number of components found in the image
   ///
   static void ConnectedComponentsImage(mitk::Image::Pointer & image, mitk::Image::Pointer& mask, mitk::Image::Pointer &outimage, unsigned int& num_components);
 
   ///
   /// \brief GrabLabel
   /// \param image
   /// \param outimage
   /// \param label
   ///
   static void GrabLabel(mitk::Image::Pointer & image, mitk::Image::Pointer & outimage, unsigned int label);
 
 
   ///
   /// \brief itkInsertLabel
   /// \param image
   /// \param maskImage
   /// \param label
   ///
   static void InsertLabel(mitk::Image::Pointer & image, mitk::Image::Pointer & maskImage, unsigned int label);
 
   ///
   /// \brief ErodeGrayscale
   /// \param image
   /// \param outimage
   /// \param radius
   /// \param d
   ///
   static void ErodeGrayscale(mitk::Image::Pointer & image, unsigned int radius, mitk::CLUtil::MorphologicalDimensions d, mitk::Image::Pointer & outimage );
 
   ///
   /// \brief DilateGrayscale
   /// \param image
   /// \param outimage
   /// \param radius
   /// \param d
   ///
   static void DilateGrayscale(mitk::Image::Pointer & image, unsigned int radius, mitk::CLUtil::MorphologicalDimensions d, mitk::Image::Pointer & outimage );
 
   ///
   /// \brief FillHoleGrayscale
   /// \param image
   /// \param outimage
   ///
   static void FillHoleGrayscale(mitk::Image::Pointer & image, mitk::Image::Pointer & outimage);
 
   ///
   /// \brief ProbabilityMap
   /// \param sourceImage
   /// \param mean
   /// \param std_dev
   /// \param resultImage
   ///
   static void ProbabilityMap(const mitk::Image::Pointer&  sourceImage, double mean, double std_dev, mitk::Image::Pointer& resultImage);
 
   template<class TImageType>
   static void itkCountVoxel( TImageType * image, std::map<unsigned int, unsigned int> & map)
   {
     auto it = itk::ImageRegionIterator< TImageType >(image,image->GetLargestPossibleRegion());
     while(!it.IsAtEnd())
     {
       if(map.find(it.Value()) == map.end())
         map[it.Value()] = 0;
       map[it.Value()]++;
       ++it;
     }
   }
 
   template <class TImageType>
   static void itkCountVoxel(TImageType* image, typename TImageType::PixelType label, unsigned int & count )
   {
     itk::ImageRegionConstIterator<TImageType> inputIter(image, image->GetLargestPossibleRegion());
     while(!inputIter.IsAtEnd())
     {
       if(inputIter.Value() == label) ++count;
       ++inputIter;
     }
   }
 
   template<typename TImageType>
   static inline void itkCountVoxel(TImageType * mask, unsigned int & n_numSamples)
   {
     auto mit = itk::ImageRegionConstIterator<TImageType>(mask, mask->GetLargestPossibleRegion());
     while (!mit.IsAtEnd())
     {
       if(mit.Value() > 0)
         n_numSamples++;
       ++mit;
     }
   }
 
   template <class TImageType1, class TImageType2>
   static void itkSampleLabel(TImageType1* image, TImageType2* output, double acceptrate, unsigned int label)
   {
     std::srand (time(nullptr));
 
     itk::ImageRegionConstIterator< TImageType1 > inputIter(image, image->GetLargestPossibleRegion());
     itk::ImageRegionIterator< TImageType2 > outputIter(output, output->GetLargestPossibleRegion());
 
     while (!inputIter.IsAtEnd())
     {
       double r = (double)(rand()) / RAND_MAX;
       if(inputIter.Get() == label && r < acceptrate)
         outputIter.Set(label);
 
       ++inputIter;
       ++outputIter;
     }
   }
 
   template <class TImageType>
   static void itkSampleLabel(TImageType* image, mitk::Image::Pointer & output, unsigned int n_samples_drawn)
   {
     std::srand (time(nullptr));
 
     typename TImageType::Pointer itk_out = TImageType::New();
     itk_out->SetRegions(image->GetLargestPossibleRegion());
     itk_out->SetDirection(image->GetDirection());
     itk_out->SetOrigin(image->GetOrigin());
     itk_out->SetSpacing(image->GetSpacing());
     itk_out->Allocate();
     itk_out->FillBuffer(0);
 
     itk::ImageRegionConstIterator< TImageType > inputIter(image, image->GetLargestPossibleRegion());
     itk::ImageRegionIterator< TImageType > outputIter(itk_out, itk_out->GetLargestPossibleRegion());
 
     for(unsigned int i = 0 ; i < n_samples_drawn ;)
     {
       double r = (double)(rand()) / RAND_MAX;
       if(inputIter.Value() != 0 && r < 0.01 && outputIter.Value() == 0)
       {
         outputIter.Set(inputIter.Value());
         i++;
       }
       ++inputIter;
       ++outputIter;
 
       if(inputIter.IsAtEnd())
       {
         inputIter.GoToBegin();
         outputIter.GoToBegin();
       }
 
     }
 
     mitk::CastToMitkImage(itk_out, output);
   }
 
 private:
 
   template<class TImageType>
   static void itkErodeGrayscale(TImageType * image, mitk::Image::Pointer & outimage , unsigned int radius, mitk::CLUtil::MorphologicalDimensions d);
 
   template<class TImageType>
   static void itkDilateGrayscale(TImageType * image, mitk::Image::Pointer & outimage , unsigned int radius, mitk::CLUtil::MorphologicalDimensions d);
 
   template<class TImageType>
   static void itkFillHoleGrayscale(TImageType * image, mitk::Image::Pointer & outimage);
 
   template< typename TImageType >
   static void itkInsertLabel(TImageType * maskImage, mitk::Image::Pointer & outimage, unsigned int label)
   {
 
     typename TImageType::Pointer itk_out;
 
     if(outimage.IsNull()) // create if necessary
     {
       MITK_INFO << "Initialize new image";
       itk_out = TImageType::New();
       itk_out->SetSpacing(maskImage->GetSpacing());
       itk_out->SetDirection(maskImage->GetDirection());
       itk_out->SetOrigin(maskImage->GetOrigin());
       itk_out->SetRegions(maskImage->GetLargestPossibleRegion());
       itk_out->Allocate();
       itk_out->FillBuffer(0);
     }else
     {
       mitk::CastToItkImage(outimage, itk_out);
     }
 
     itk::ImageRegionIterator<TImageType> oit(itk_out,itk_out->GetLargestPossibleRegion());
     itk::ImageRegionConstIterator<TImageType> mit(maskImage,maskImage->GetLargestPossibleRegion());
 
     while(!mit.IsAtEnd())
     {
       if(mit.Value() != 0)
       {
         oit.Set(label);
       }
       ++oit;
       ++mit;
     }
 
     mitk::CastToMitkImage(itk_out,outimage);
   }
 
 
   template< typename TImageType >
   static void itkGrabLabel(TImageType * image, mitk::Image::Pointer & outimage, unsigned int label)
   {
     typedef itk::Image<unsigned short, 3> TOutType;
     TOutType::Pointer itk_out = TOutType::New();
     itk_out->SetRegions(image->GetLargestPossibleRegion());
     itk_out->SetDirection(image->GetDirection());
     itk_out->SetOrigin(image->GetOrigin());
     itk_out->SetSpacing(image->GetSpacing());
     itk_out->Allocate();
 
     itk::ImageRegionConstIterator<TImageType> iit(image, image->GetLargestPossibleRegion());
     itk::ImageRegionIterator<TOutType> oit(itk_out,itk_out->GetLargestPossibleRegion());
 
     while(!iit.IsAtEnd())
     {
       if(iit.Value() == static_cast<typename TImageType::PixelType>(label))
         oit.Set(1);
       else
         oit.Set(0);
 
       ++iit;
       ++oit;
     }
 
     mitk::CastToMitkImage(itk_out, outimage);
   }
 
   template<class TImagetype>
   static void itkMergeLabels(TImagetype * img, const std::map<unsigned int, unsigned int> & map)
   {
 
     auto it = itk::ImageRegionIterator<TImagetype>(img,img->GetLargestPossibleRegion());
 
     while(!it.IsAtEnd())
     {
       if(map.find(it.Value())!=map.end())
         it.Set( map.at(it.Value()) );
       ++it;
     }
 
   }
 
   template<typename TImageType>
   static void itkConnectedComponentsImage(TImageType * image, mitk::Image::Pointer& mask, mitk::Image::Pointer &outimage, unsigned int& num_components)
   {
     typedef itk::Image<unsigned short, 3> MaskImageType;
     MaskImageType::Pointer itk_mask;
     if(mask.IsNull())
     {
       itk_mask = MaskImageType::New();
       itk_mask->SetRegions(image->GetLargestPossibleRegion());
       itk_mask->SetDirection(image->GetDirection());
       itk_mask->SetOrigin(image->GetOrigin());
       itk_mask->SetSpacing(image->GetSpacing());
       itk_mask->Allocate();
       itk_mask->FillBuffer(1);
     }else{
       mitk::CastToItkImage(mask,itk_mask);
     }
 
     typedef itk::ConnectedComponentImageFilter<TImageType, MaskImageType, MaskImageType > FilterType;
     typename FilterType::Pointer cc_filter = FilterType::New();
     cc_filter->SetMaskImage(itk_mask.GetPointer());
     cc_filter->SetInput(image);
     cc_filter->SetBackgroundValue(0);
     cc_filter->Update();
 
     num_components = cc_filter->GetObjectCount();
     mitk::CastToMitkImage(cc_filter->GetOutput(), outimage);
   }
 
   template< typename TImageType >
   static void itkCreateCheckerboardMask(TImageType * image, mitk::Image::Pointer & outimage);
 
   template< typename TImageType >
   static void itkInterpolateCheckerboardPrediction(TImageType * checkerboard_prediction, mitk::Image::Pointer & checkerboard_mask, mitk::Image::Pointer & outimage);
 
   template <class TImageType>
   static void itkSumVoxelForLabel(TImageType* image, const mitk::Image::Pointer & source , typename TImageType::PixelType label, double & val );
 
   template <class TImageType>
   static void itkSqSumVoxelForLabel(TImageType* image, const mitk::Image::Pointer & source, typename TImageType::PixelType label, double & val );
 
   template<typename TStructuringElement>
   static void itkFitStructuringElement(TStructuringElement & se, MorphologicalDimensions d, int radius);
 
   template<typename TImageType>
   static void itkDilateBinary(TImageType * sourceImage, mitk::Image::Pointer& resultImage, int radius , MorphologicalDimensions d);
 
   template<typename TImageType>
   static void itkErodeBinary(TImageType * sourceImage, mitk::Image::Pointer& resultImage, int radius, MorphologicalDimensions d);
 
   template<typename TImageType>
   static void itkClosingBinary(TImageType * sourceImage, mitk::Image::Pointer& resultImage, int radius, MorphologicalDimensions d);
 
   template<typename TPixel, unsigned int VDimension>
   static void itkFillHolesBinary(itk::Image<TPixel, VDimension>* sourceImage, mitk::Image::Pointer& resultImage);
 
   template<typename TImageType>
   static void itkLogicalAndImages(const TImageType * image1, const mitk::Image::Pointer & image2, mitk::Image::Pointer & outimage);
 
   template<class TImageType>
   static void itkGaussianFilter(TImageType * image, mitk::Image::Pointer & smoothed ,double sigma);
 
   template<class TImageType>
   static void itkDifferenceOfGaussianFilter(TImageType * image, mitk::Image::Pointer & smoothed, double sigma1, double sigma2);
 
   template<typename TImageType>
   static void itkProbabilityMap(const TImageType * sourceImage, double mean, double std_dev, mitk::Image::Pointer& resultImage);
 
   template<typename TPixel, unsigned int VImageDimension>
   static void itkHessianOfGaussianFilter(itk::Image<TPixel, VImageDimension>* itkImage, double variance, std::vector<mitk::Image::Pointer> &out);
 
   template<typename TPixel, unsigned int VImageDimension>
   static void itkLaplacianOfGaussianFilter(itk::Image<TPixel, VImageDimension>* itkImage, double variance, mitk::Image::Pointer &output);
 
   template<typename TPixel, unsigned int VImageDimension>
   static void itkLocalHistograms(itk::Image<TPixel, VImageDimension>* itkImage, std::vector<mitk::Image::Pointer> &out, int size, int bins);
 };
 
 } //namespace MITK
 
 #endif
diff --git a/Modules/Classification/CLUtilities/src/mitkCLUtil.cpp b/Modules/Classification/CLUtilities/src/mitkCLUtil.cpp
index 115d7c8630..d67040b3f6 100644
--- a/Modules/Classification/CLUtilities/src/mitkCLUtil.cpp
+++ b/Modules/Classification/CLUtilities/src/mitkCLUtil.cpp
@@ -1,642 +1,642 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef _mitkCLUtil_HXX
 #define _mitkCLUtil_HXX
 
 #include <mitkCLUtil.h>
 
 #include <mitkImageAccessByItk.h>
 
 
 
 #include <Eigen/Dense>
 #include <itkImage.h>
 
 // itk includes
 #include <itkCheckerBoardImageFilter.h>
 #include <itkShapedNeighborhoodIterator.h>
 #include "itkHessianRecursiveGaussianImageFilter.h"
 #include "itkUnaryFunctorImageFilter.h"
 #include "vnl/algo/vnl_symmetric_eigensystem.h"
 #include <itkLaplacianRecursiveGaussianImageFilter.h>
 #include <itkMultiHistogramFilter.h>
 
 // Morphologic Operations
 #include <itkBinaryBallStructuringElement.h>
 #include <itkBinaryDilateImageFilter.h>
 #include <itkBinaryErodeImageFilter.h>
 #include <itkBinaryFillholeImageFilter.h>
 #include <itkBinaryMorphologicalClosingImageFilter.h>
 #include <itkGrayscaleErodeImageFilter.h>
 #include <itkGrayscaleDilateImageFilter.h>
 #include <itkGrayscaleFillholeImageFilter.h>
 
 // Image Filter
 #include <itkDiscreteGaussianImageFilter.h>
 #include <itkSubtractImageFilter.h>
 
 void mitk::CLUtil::ProbabilityMap(const mitk::Image::Pointer & image , double mean, double stddev, mitk::Image::Pointer & outimage)
 {
   AccessFixedDimensionByItk_3(image, mitk::CLUtil::itkProbabilityMap, 3, mean, stddev, outimage);
 }
 
 void mitk::CLUtil::ErodeGrayscale(mitk::Image::Pointer & image , unsigned int radius, mitk::CLUtil::MorphologicalDimensions d, mitk::Image::Pointer & outimage)
 {
   AccessFixedDimensionByItk_3(image, mitk::CLUtil::itkErodeGrayscale, 3, outimage, radius, d);
 }
 
 void mitk::CLUtil::DilateGrayscale(mitk::Image::Pointer & image, unsigned int radius, mitk::CLUtil::MorphologicalDimensions d, mitk::Image::Pointer & outimage)
 {
   AccessFixedDimensionByItk_3(image, mitk::CLUtil::itkDilateGrayscale, 3, outimage, radius, d);
 }
 
 void mitk::CLUtil::FillHoleGrayscale(mitk::Image::Pointer & image, mitk::Image::Pointer & outimage)
 {
   AccessFixedDimensionByItk_1(image, mitk::CLUtil::itkFillHoleGrayscale, 3, outimage);
 }
 
 void mitk::CLUtil::InsertLabel(mitk::Image::Pointer & image, mitk::Image::Pointer & maskImage, unsigned int label)
 {
   AccessByItk_2(image, mitk::CLUtil::itkInsertLabel, maskImage, label);
 }
 
 void mitk::CLUtil::GrabLabel(mitk::Image::Pointer & image, mitk::Image::Pointer & outimage, unsigned int label)
 {
   AccessFixedDimensionByItk_2(image, mitk::CLUtil::itkGrabLabel, 3, outimage, label);
 }
 
 void mitk::CLUtil::ConnectedComponentsImage(mitk::Image::Pointer & image, mitk::Image::Pointer& mask, mitk::Image::Pointer &outimage, unsigned int& num_components)
 {
   AccessFixedDimensionByItk_3(image, mitk::CLUtil::itkConnectedComponentsImage,3, mask, outimage, num_components);
 }
 
 void mitk::CLUtil::MergeLabels(mitk::Image::Pointer & img, const std::map<unsigned int, unsigned int> & map)
 {
   AccessByItk_1(img, mitk::CLUtil::itkMergeLabels, map);
 }
 
 void mitk::CLUtil::CountVoxel(mitk::Image::Pointer image, std::map<unsigned int, unsigned int> & map)
 {
   AccessByItk_1(image, mitk::CLUtil::itkCountVoxel, map);
 }
 
 void mitk::CLUtil::CountVoxel(mitk::Image::Pointer image, unsigned int label, unsigned int & count)
 {
   AccessByItk_2(image, mitk::CLUtil::itkCountVoxel, label, count);
 }
 
 void mitk::CLUtil::CountVoxel(mitk::Image::Pointer image, unsigned int & count)
 {
   AccessByItk_1(image, mitk::CLUtil::itkCountVoxel, count);
 }
 
 void mitk::CLUtil::CreateCheckerboardMask(mitk::Image::Pointer image, mitk::Image::Pointer & outimage)
 {
   AccessFixedDimensionByItk_1(image, mitk::CLUtil::itkCreateCheckerboardMask,3, outimage);
 }
 
 void mitk::CLUtil::LogicalAndImages(const mitk::Image::Pointer & image1, const mitk::Image::Pointer & image2, mitk::Image::Pointer & outimage)
 {
   AccessFixedDimensionByItk_2(image1,itkLogicalAndImages, 3, image2, outimage);
 
 }
 
 void mitk::CLUtil::InterpolateCheckerboardPrediction(mitk::Image::Pointer checkerboard_prediction, mitk::Image::Pointer & checkerboard_mask, mitk::Image::Pointer & outimage)
 {
   AccessFixedDimensionByItk_2(checkerboard_prediction, mitk::CLUtil::itkInterpolateCheckerboardPrediction,3, checkerboard_mask, outimage);
 }
 
 void mitk::CLUtil::GaussianFilter(mitk::Image::Pointer image, mitk::Image::Pointer & smoothed ,double sigma)
 {
   AccessFixedDimensionByItk_2(image, mitk::CLUtil::itkGaussianFilter,3, smoothed, sigma);
 }
 
 void mitk::CLUtil::DifferenceOfGaussianFilter(mitk::Image::Pointer image, mitk::Image::Pointer & smoothed, double sigma1, double sigma2)
 {
   AccessFixedDimensionByItk_3(image, mitk::CLUtil::itkDifferenceOfGaussianFilter, 3, smoothed, sigma1, sigma2);
 }
 
 void mitk::CLUtil::LaplacianOfGaussianFilter(mitk::Image::Pointer image, mitk::Image::Pointer & smoothed, double sigma1)
 {
   AccessByItk_2(image, mitk::CLUtil::itkLaplacianOfGaussianFilter, sigma1, smoothed);
 }
 
 void mitk::CLUtil::HessianOfGaussianFilter(mitk::Image::Pointer image, std::vector<mitk::Image::Pointer> &out, double sigma)
 {
   AccessByItk_2(image, mitk::CLUtil::itkHessianOfGaussianFilter, sigma, out);
 }
 
 void mitk::CLUtil::LocalHistogram(mitk::Image::Pointer image, std::vector<mitk::Image::Pointer> &out, int Bins, int NeighbourhoodSize)
 {
   AccessByItk_3(image, mitk::CLUtil::itkLocalHistograms, out, NeighbourhoodSize, Bins);
 }
 
 
 
 void mitk::CLUtil::DilateBinary(mitk::Image::Pointer & sourceImage, mitk::Image::Pointer& resultImage, int factor , MorphologicalDimensions d)
 {
   AccessFixedDimensionByItk_3(sourceImage, mitk::CLUtil::itkDilateBinary, 3, resultImage, factor, d);
 }
 
 
 void mitk::CLUtil::ErodeBinary(mitk::Image::Pointer & sourceImage, mitk::Image::Pointer& resultImage, int factor, MorphologicalDimensions d)
 {
   AccessFixedDimensionByItk_3(sourceImage, mitk::CLUtil::itkErodeBinary, 3, resultImage, factor, d);
 }
 
 
 void mitk::CLUtil::ClosingBinary(mitk::Image::Pointer & sourceImage, mitk::Image::Pointer& resultImage, int factor, MorphologicalDimensions d)
 {
   AccessFixedDimensionByItk_3(sourceImage, mitk::CLUtil::itkClosingBinary, 3, resultImage, factor, d);
 }
 
 template<typename TImageType>
 void mitk::CLUtil::itkProbabilityMap(const TImageType * sourceImage, double mean, double std_dev, mitk::Image::Pointer& resultImage)
 {
   itk::Image<double, 3>::Pointer itk_img = itk::Image<double, 3>::New();
   itk_img->SetRegions(sourceImage->GetLargestPossibleRegion());
   itk_img->SetOrigin(sourceImage->GetOrigin());
   itk_img->SetSpacing(sourceImage->GetSpacing());
   itk_img->SetDirection(sourceImage->GetDirection());
   itk_img->Allocate();
 
 
   itk::ImageRegionConstIterator<TImageType> it(sourceImage,sourceImage->GetLargestPossibleRegion());
   itk::ImageRegionIterator<itk::Image<double, 3> > outit(itk_img,itk_img->GetLargestPossibleRegion());
 
   while(!it.IsAtEnd())
   {
     double x = it.Value();
 
     double prob = (1.0/(std_dev*std::sqrt(2.0*itk::Math::pi))) * std::exp(-(((x-mean)*(x-mean))/(2.0*std_dev*std_dev)));
     outit.Set(prob);
     ++it;
     ++outit;
   }
 
   mitk::CastToMitkImage(itk_img, resultImage);
 }
 
 template< typename TImageType >
 void mitk::CLUtil::itkInterpolateCheckerboardPrediction(TImageType * checkerboard_prediction, Image::Pointer &checkerboard_mask, mitk::Image::Pointer & outimage)
 {
   typename TImageType::Pointer itk_checkerboard_mask;
   mitk::CastToItkImage(checkerboard_mask,itk_checkerboard_mask);
 
   typename TImageType::Pointer itk_outimage = TImageType::New();
   itk_outimage->SetRegions(checkerboard_prediction->GetLargestPossibleRegion());
   itk_outimage->SetDirection(checkerboard_prediction->GetDirection());
   itk_outimage->SetOrigin(checkerboard_prediction->GetOrigin());
   itk_outimage->SetSpacing(checkerboard_prediction->GetSpacing());
   itk_outimage->Allocate();
   itk_outimage->FillBuffer(0);
 
   //typedef typename itk::ShapedNeighborhoodIterator<TImageType>::SizeType SizeType;
   typedef itk::Size<3> SizeType;
   SizeType size;
   size.Fill(1);
   itk::ShapedNeighborhoodIterator<TImageType> iit(size,checkerboard_prediction,checkerboard_prediction->GetLargestPossibleRegion());
   itk::ShapedNeighborhoodIterator<TImageType> mit(size,itk_checkerboard_mask,itk_checkerboard_mask->GetLargestPossibleRegion());
   itk::ImageRegionIterator<TImageType> oit(itk_outimage,itk_outimage->GetLargestPossibleRegion());
 
   typedef typename itk::ShapedNeighborhoodIterator<TImageType>::OffsetType OffsetType;
   OffsetType offset;
   offset.Fill(0);
   offset[0] = 1;       // {1,0,0}
   iit.ActivateOffset(offset);
   mit.ActivateOffset(offset);
   offset[0] = -1;      // {-1,0,0}
   iit.ActivateOffset(offset);
   mit.ActivateOffset(offset);
   offset[0] = 0; offset[1] = 1; //{0,1,0}
   iit.ActivateOffset(offset);
   mit.ActivateOffset(offset);
   offset[1] = -1;      //{0,-1,0}
   iit.ActivateOffset(offset);
   mit.ActivateOffset(offset);
 
   //    iit.ActivateOffset({{0,0,1}});
   //    iit.ActivateOffset({{0,0,-1}});
   //    mit.ActivateOffset({{0,0,1}});
   //    mit.ActivateOffset({{0,0,-1}});
 
   while(!iit.IsAtEnd())
   {
     if(mit.GetCenterPixel() == 0)
     {
       typename TImageType::PixelType mean = 0;
       for (auto i = iit.Begin(); ! i.IsAtEnd(); i++)
       { mean += i.Get(); }
 
 
       //std::sort(list.begin(),list.end(),[](const typename TImageType::PixelType x,const typename TImageType::PixelType y){return x<=y;});
 
       oit.Set((mean+0.5)/6.0);
     }
     else
     {
       oit.Set(iit.GetCenterPixel());
     }
     ++iit;
     ++mit;
     ++oit;
   }
 
   mitk::CastToMitkImage(itk_outimage,outimage);
 }
 
 template< typename TImageType >
 void mitk::CLUtil::itkCreateCheckerboardMask(TImageType * image, mitk::Image::Pointer & outimage)
 {
   typename TImageType::Pointer zeroimg = TImageType::New();
   zeroimg->SetRegions(image->GetLargestPossibleRegion());
   zeroimg->SetDirection(image->GetDirection());
   zeroimg->SetOrigin(image->GetOrigin());
   zeroimg->SetSpacing(image->GetSpacing());
 
   zeroimg->Allocate();
   zeroimg->FillBuffer(0);
 
   typedef itk::CheckerBoardImageFilter<TImageType> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
   filter->SetInput1(image);
   filter->SetInput2(zeroimg);
   typename FilterType::PatternArrayType pattern;
   pattern.SetElement(0,(image->GetLargestPossibleRegion().GetSize()[0]));
   pattern.SetElement(1,(image->GetLargestPossibleRegion().GetSize()[1]));
   pattern.SetElement(2,(image->GetLargestPossibleRegion().GetSize()[2]));
   filter->SetCheckerPattern(pattern);
 
   filter->Update();
   mitk::CastToMitkImage(filter->GetOutput(), outimage);
 }
 
 
 template <class TImageType>
 void mitk::CLUtil::itkSumVoxelForLabel(TImageType* image, const mitk::Image::Pointer & source , typename TImageType::PixelType label, double & val )
 {
   itk::Image<double,3>::Pointer itk_source;
   mitk::CastToItkImage(source,itk_source);
 
   itk::ImageRegionConstIterator<TImageType> inputIter(image, image->GetLargestPossibleRegion());
   itk::ImageRegionConstIterator< itk::Image<double,3> > sourceIter(itk_source, itk_source->GetLargestPossibleRegion());
   while(!inputIter.IsAtEnd())
   {
     if(inputIter.Value() == label) val += sourceIter.Value();
     ++inputIter;
     ++sourceIter;
   }
 }
 
 template <class TImageType>
 void mitk::CLUtil::itkSqSumVoxelForLabel(TImageType* image, const mitk::Image::Pointer & source, typename TImageType::PixelType label, double & val )
 {
   itk::Image<double,3>::Pointer itk_source;
   mitk::CastToItkImage(source,itk_source);
 
   itk::ImageRegionConstIterator<TImageType> inputIter(image, image->GetLargestPossibleRegion());
   itk::ImageRegionConstIterator< itk::Image<double,3> > sourceIter(itk_source, itk_source->GetLargestPossibleRegion());
   while(!inputIter.IsAtEnd())
   {
     if(inputIter.Value() == label) val += sourceIter.Value() * sourceIter.Value();
     ++inputIter;
     ++sourceIter;
   }
 }
 
 template<typename TStructuringElement>
 void mitk::CLUtil::itkFitStructuringElement(TStructuringElement & se, MorphologicalDimensions d, int factor)
 {
   typename TStructuringElement::SizeType size;
   size.Fill(factor);
   switch(d)
   {
   case(All):
   case(Axial):
     size.SetElement(2,0);
     break;
-  case(Sagital):
+  case(Sagittal):
     size.SetElement(0,0);
     break;
   case(Coronal):
     size.SetElement(1,0);
     break;
   }
   se.SetRadius(size);
   se.CreateStructuringElement();
 }
 
 template<typename TImageType>
 void mitk::CLUtil::itkClosingBinary(TImageType * sourceImage, mitk::Image::Pointer& resultImage, int factor, MorphologicalDimensions d)
 {
   typedef itk::BinaryBallStructuringElement<typename TImageType::PixelType, 3> BallType;
   typedef itk::BinaryMorphologicalClosingImageFilter<TImageType, TImageType, BallType> FilterType;
 
   BallType strElem;
   itkFitStructuringElement(strElem,d,factor);
 
   typename FilterType::Pointer erodeFilter = FilterType::New();
   erodeFilter->SetKernel(strElem);
   erodeFilter->SetInput(sourceImage);
   erodeFilter->SetForegroundValue(1);
   erodeFilter->Update();
 
   mitk::CastToMitkImage(erodeFilter->GetOutput(), resultImage);
 
 }
 
 template<typename TImageType>
 void mitk::CLUtil::itkDilateBinary(TImageType * sourceImage, mitk::Image::Pointer& resultImage, int factor, MorphologicalDimensions d)
 {
   typedef itk::BinaryBallStructuringElement<typename TImageType::PixelType, 3> BallType;
   typedef typename itk::BinaryDilateImageFilter<TImageType, TImageType, BallType> BallDilateFilterType;
 
   BallType strElem;
   itkFitStructuringElement(strElem,d,factor);
 
   typename BallDilateFilterType::Pointer erodeFilter = BallDilateFilterType::New();
   erodeFilter->SetKernel(strElem);
   erodeFilter->SetInput(sourceImage);
   erodeFilter->SetDilateValue(1);
   erodeFilter->Update();
 
   mitk::CastToMitkImage(erodeFilter->GetOutput(), resultImage);
 
 }
 
 template<typename TImageType>
 void mitk::CLUtil::itkErodeBinary(TImageType * sourceImage, mitk::Image::Pointer& resultImage, int factor, MorphologicalDimensions d)
 {
   typedef itk::BinaryBallStructuringElement<typename TImageType::PixelType, 3> BallType;
   typedef typename itk::BinaryErodeImageFilter<TImageType, TImageType, BallType> BallErodeFilterType;
 
   BallType strElem;
   itkFitStructuringElement(strElem,d,factor);
 
 
   typename BallErodeFilterType::Pointer erodeFilter = BallErodeFilterType::New();
   erodeFilter->SetKernel(strElem);
   erodeFilter->SetInput(sourceImage);
   erodeFilter->SetErodeValue(1);
 //  erodeFilter->UpdateLargestPossibleRegion();
   erodeFilter->Update();
 
   mitk::CastToMitkImage(erodeFilter->GetOutput(), resultImage);
 
 }
 
 ///
 /// \brief itkFillHolesBinary
 /// \param sourceImage
 /// \param resultImage
 ///
 template<typename TPixel, unsigned int VDimension>
 void mitk::CLUtil::itkFillHolesBinary(itk::Image<TPixel, VDimension>* sourceImage, mitk::Image::Pointer& resultImage)
 {
   typedef itk::Image<TPixel, VDimension> ImageType;
   typedef typename itk::BinaryFillholeImageFilter<ImageType> FillHoleFilterType;
 
   typename FillHoleFilterType::Pointer fillHoleFilter = FillHoleFilterType::New();
   fillHoleFilter->SetInput(sourceImage);
   fillHoleFilter->SetForegroundValue(1);
   fillHoleFilter->Update();
 
   mitk::CastToMitkImage(fillHoleFilter->GetOutput(), resultImage);
 }
 
 ///
 /// \brief itkLogicalAndImages
 /// \param image1 keep the values of image 1
 /// \param image2
 ///
 template<typename TImageType>
 void mitk::CLUtil::itkLogicalAndImages(const TImageType * image1, const mitk::Image::Pointer & image2, mitk::Image::Pointer & outimage)
 {
 
   typename TImageType::Pointer itk_outimage = TImageType::New();
   itk_outimage->SetRegions(image1->GetLargestPossibleRegion());
   itk_outimage->SetDirection(image1->GetDirection());
   itk_outimage->SetOrigin(image1->GetOrigin());
   itk_outimage->SetSpacing(image1->GetSpacing());
 
   itk_outimage->Allocate();
   itk_outimage->FillBuffer(0);
 
   typename TImageType::Pointer itk_image2;
   mitk::CastToItkImage(image2,itk_image2);
 
   itk::ImageRegionConstIterator<TImageType> it1(image1, image1->GetLargestPossibleRegion());
   itk::ImageRegionConstIterator<TImageType> it2(itk_image2, itk_image2->GetLargestPossibleRegion());
   itk::ImageRegionIterator<TImageType> oit(itk_outimage,itk_outimage->GetLargestPossibleRegion());
 
   while(!it1.IsAtEnd())
   {
     if(it1.Value() == 0 || it2.Value() == 0)
     {
       oit.Set(0);
     }else
       oit.Set(it1.Value());
     ++it1;
     ++it2;
     ++oit;
   }
 
   mitk::CastToMitkImage(itk_outimage, outimage);
 }
 
 ///
 /// \brief GaussianFilter
 /// \param image
 /// \param smoothed
 /// \param sigma
 ///
 template<class TImageType>
 void mitk::CLUtil::itkGaussianFilter(TImageType * image, mitk::Image::Pointer & smoothed ,double sigma)
 {
   typedef itk::DiscreteGaussianImageFilter<TImageType,TImageType> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
   filter->SetInput(image);
   filter->SetVariance(sigma);
   filter->Update();
 
   mitk::CastToMitkImage(filter->GetOutput(),smoothed);
 }
 
 template<class TImageType>
 void mitk::CLUtil::itkDifferenceOfGaussianFilter(TImageType * image, mitk::Image::Pointer & smoothed, double sigma1, double sigma2)
 {
   typedef itk::DiscreteGaussianImageFilter<TImageType, TImageType> FilterType;
   typedef itk::SubtractImageFilter <TImageType, TImageType> SubtractFilterType;
   typename FilterType::Pointer filter1 = FilterType::New();
   typename FilterType::Pointer filter2 = FilterType::New();
   typename SubtractFilterType::Pointer subFilter = SubtractFilterType::New();
   filter1->SetInput(image);
   filter1->SetVariance(sigma1);
   filter1->Update();
   filter2->SetInput(image);
   filter2->SetVariance(sigma2);
   filter2->Update();
   subFilter->SetInput1(filter1->GetOutput());
   subFilter->SetInput2(filter2->GetOutput());
   subFilter->Update();
 
   mitk::CastToMitkImage(subFilter->GetOutput(), smoothed);
 }
 
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::CLUtil::itkLaplacianOfGaussianFilter(itk::Image<TPixel, VImageDimension>* itkImage, double variance, mitk::Image::Pointer &output)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::DiscreteGaussianImageFilter< ImageType, ImageType >  GaussFilterType;
   typedef itk::LaplacianRecursiveGaussianImageFilter<ImageType, ImageType>    LaplacianFilter;
 
   typename GaussFilterType::Pointer gaussianFilter = GaussFilterType::New();
   gaussianFilter->SetInput(itkImage);
   gaussianFilter->SetVariance(variance);
   gaussianFilter->Update();
   typename LaplacianFilter::Pointer laplaceFilter = LaplacianFilter::New();
   laplaceFilter->SetInput(gaussianFilter->GetOutput());
   laplaceFilter->Update();
   mitk::CastToMitkImage(laplaceFilter->GetOutput(), output);
 }
 
 namespace Functor
 {
   template <class TInput, class TOutput>
   class MatrixFirstEigenvalue
   {
   public:
     MatrixFirstEigenvalue() {}
     virtual ~MatrixFirstEigenvalue() {}
 
     int order;
 
     inline TOutput operator ()(const TInput& input)
     {
       double a, b, c;
       if (input[0] < 0.01 && input[1] < 0.01 &&input[2] < 0.01 &&input[3] < 0.01 &&input[4] < 0.01 &&input[5] < 0.01)
         return 0;
       vnl_symmetric_eigensystem_compute_eigenvals(input[0], input[1], input[2], input[3], input[4], input[5], a, b, c);
       switch (order)
       {
       case 0: return a;
       case 1: return b;
       case 2: return c;
       default: return a;
       }
     }
     bool operator !=(const MatrixFirstEigenvalue) const
     {
       return false;
     }
     bool operator ==(const MatrixFirstEigenvalue& other) const
     {
       return !(*this != other);
     }
   };
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::CLUtil::itkHessianOfGaussianFilter(itk::Image<TPixel, VImageDimension>* itkImage, double variance, std::vector<mitk::Image::Pointer> &out)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<double, VImageDimension> FloatImageType;
   typedef itk::HessianRecursiveGaussianImageFilter <ImageType> HessianFilterType;
   typedef typename HessianFilterType::OutputImageType VectorImageType;
   typedef Functor::MatrixFirstEigenvalue<typename VectorImageType::PixelType, double> DeterminantFunctorType;
   typedef itk::UnaryFunctorImageFilter<VectorImageType, FloatImageType, DeterminantFunctorType> DetFilterType;
 
   typename HessianFilterType::Pointer hessianFilter = HessianFilterType::New();
   hessianFilter->SetInput(itkImage);
   hessianFilter->SetSigma(std::sqrt(variance));
   for (unsigned int i = 0; i < VImageDimension; ++i)
   {
     mitk::Image::Pointer tmpImage = mitk::Image::New();
     typename DetFilterType::Pointer detFilter = DetFilterType::New();
     detFilter->SetInput(hessianFilter->GetOutput());
     detFilter->GetFunctor().order = i;
     detFilter->Update();
     mitk::CastToMitkImage(detFilter->GetOutput(), tmpImage);
     out.push_back(tmpImage);
   }
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::CLUtil::itkLocalHistograms(itk::Image<TPixel, VImageDimension>* itkImage, std::vector<mitk::Image::Pointer> &out, int size, int bins)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::MultiHistogramFilter <ImageType, ImageType> MultiHistogramType;
 
   typename MultiHistogramType::Pointer filter = MultiHistogramType::New();
   filter->SetInput(itkImage);
   filter->SetUseImageIntensityRange(true);
   filter->SetSize(size);
   filter->SetBins(bins);
   filter->Update();
   for (int i = 0; i < bins; ++i)
   {
     mitk::Image::Pointer img = mitk::Image::New();
     mitk::CastToMitkImage(filter->GetOutput(i), img);
     out.push_back(img);
   }
 }
 
 template<class TImageType>
 void mitk::CLUtil::itkErodeGrayscale(TImageType * image, mitk::Image::Pointer & outimage , unsigned int radius, mitk::CLUtil::MorphologicalDimensions d)
 {
   typedef itk::BinaryBallStructuringElement<typename TImageType::PixelType, 3>          StructureElementType;
   typedef itk::GrayscaleErodeImageFilter<TImageType,TImageType,StructureElementType>    FilterType;
 
   StructureElementType ball;
   itkFitStructuringElement(ball,d, radius);
 
   typename FilterType::Pointer filter = FilterType::New();
   filter->SetKernel(ball);
   filter->SetInput(image);
   filter->Update();
 
   mitk::CastToMitkImage(filter->GetOutput(),outimage);
 }
 
 template<class TImageType>
 void mitk::CLUtil::itkDilateGrayscale(TImageType * image, mitk::Image::Pointer & outimage , unsigned int radius, mitk::CLUtil::MorphologicalDimensions d)
 {
   typedef itk::BinaryBallStructuringElement<typename TImageType::PixelType, 3>          StructureElementType;
   typedef itk::GrayscaleDilateImageFilter<TImageType,TImageType,StructureElementType>    FilterType;
 
   StructureElementType ball;
   itkFitStructuringElement(ball,d, radius);
 
   typename FilterType::Pointer filter = FilterType::New();
   filter->SetKernel(ball);
   filter->SetInput(image);
   filter->Update();
 
   mitk::CastToMitkImage(filter->GetOutput(),outimage);
 }
 
 template<class TImageType>
 void mitk::CLUtil::itkFillHoleGrayscale(TImageType * image, mitk::Image::Pointer & outimage)
 {
   typedef itk::GrayscaleFillholeImageFilter<TImageType,TImageType>    FilterType;
 
   typename FilterType::Pointer filter = FilterType::New();
   filter->SetInput(image);
   filter->Update();
 
   mitk::CastToMitkImage(filter->GetOutput(),outimage);
 }
 
 
 #endif
diff --git a/Modules/Core/CMakeLists.txt b/Modules/Core/CMakeLists.txt
index 27d967637d..0d72d5511a 100644
--- a/Modules/Core/CMakeLists.txt
+++ b/Modules/Core/CMakeLists.txt
@@ -1,77 +1,78 @@
 set(TOOL_CPPS "")
 
 # temporary suppress warnings in the following files until image accessors are fully integrated.
 set_source_files_properties( src/DataManagement/mitkImage.cpp COMPILE_FLAGS -DMITK_NO_DEPRECATED_WARNINGS )
 set_source_files_properties( src/Controllers/mitkSliceNavigationController.cpp COMPILE_FLAGS -DMITK_NO_DEPRECATED_WARNINGS )
 
 #if(MSVC)
 #  set(optional_private_package_depends psapi)
 #endif()
 
 mitk_create_module(
   INCLUDE_DIRS
     PUBLIC
       ${MITK_BINARY_DIR}
     PRIVATE
       src/Algorithms
       src/Controllers
       src/DataManagement
       src/Interactions
       src/IO
       src/Rendering
   DEPENDS
     PUBLIC
       mbilog
       CppMicroServices
   PACKAGE_DEPENDS
     PUBLIC
       Boost
       ITK|IOImageBase+SpatialObjects+Statistics
       #ITK|Statistics+Transform
       VTK|FiltersTexture+FiltersParallel+ImagingStencil+ImagingMath+InteractionStyle+RenderingOpenGL2+RenderingVolumeOpenGL2+RenderingFreeType+RenderingLabel+InteractionWidgets+IOGeometry+IOXML
     PRIVATE
       ITK|IOBioRad+IOBMP+IOBruker+IOCSV+IOGDCM+IOGE+IOGIPL+IOHDF5+IOIPL+IOJPEG+IOJPEG2000+IOLSM+IOMesh+IOMeta+IOMINC+IOMRC+IONIFTI+IONRRD+IOPNG+IOSiemens+IOSpatialObjects+IOStimulate+IOTIFF+IOTransformBase+IOTransformHDF5+IOTransformInsightLegacy+IOTransformMatlab+IOVTK+IOXML
+      nlohmann_json
       tinyxml2
       ${optional_private_package_depends}
   # Do not automatically create CppMicroServices initialization code.
   # Because the VTK "auto-init" functionality injects file-local static
   # initialization code in every cpp file which includes a VTK header,
   # static initialization order becomes an issue again. For the Mitk
   # core library, we need to ensure that the VTK static initialization stuff
   # happens before the CppMicroServices initialization, since the latter
   # might already use VTK code which needs to access VTK object factories.
   # Hence, CppMicroServices initialization code is placed manually within
   # the mitkCoreActivator.cpp file.
   NO_INIT
 )
 if(NOT TARGET ${MODULE_TARGET})
   message(SEND_ERROR "Core target ${MODULE_TARGET} does not exist")
 endif()
 
 function(_itk_create_factory_register_manager)
   # In MITK_ITK_Config.cmake, we do *not* include ITK_USE_FILE, which
   # prevents multiple registrations/unregistrations of ITK IO factories
   # during library loading/unloading (of MITK libraries). However, we need
   # "one" place where the IO factories are registered at
   # least once. This could be the application executable, but every executable would
   # need to take care of that itself. Instead, we allow the auto registration in the
   # Mitk Core library.
   set(NO_DIRECTORY_SCOPED_ITK_COMPILE_DEFINITION 1)
   find_package(ITK)
   include(${ITK_USE_FILE})
 
   if(NOT ITK_NO_IO_FACTORY_REGISTER_MANAGER)
     # We manually add the define which will be of target scope. MITK
     # patches ITK_USE_FILE to remove the directory scoped compile
     # definition since it would be propagated to other targets in the
     # same directory scope but these targets might want to *not*
     # use the ITK factory manager stuff.
     target_compile_definitions(${MODULE_TARGET} PRIVATE ITK_IO_FACTORY_REGISTER_MANAGER)
   endif()
 endfunction()
 _itk_create_factory_register_manager()
 
 if(BUILD_TESTING)
   add_subdirectory(TestingHelper)
   add_subdirectory(test)
 endif()
diff --git a/Modules/Core/include/mitkImageTimeSelector.h b/Modules/Core/include/mitkImageTimeSelector.h
index ea52c6dbdd..a76022cf7e 100644
--- a/Modules/Core/include/mitkImageTimeSelector.h
+++ b/Modules/Core/include/mitkImageTimeSelector.h
@@ -1,60 +1,78 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef IMAGETIMESELECTOR_H_HEADER_INCLUDED_C1E4861D
 #define IMAGETIMESELECTOR_H_HEADER_INCLUDED_C1E4861D
 
 #include "mitkSubImageSelector.h"
 #include <MitkCoreExports.h>
 
 namespace mitk
 {
   //##Documentation
   //## @brief Provides access to a volume at a specific time of the input image
   //##
   //## If the input is generated by a ProcessObject, only the required data is
   //## requested.
   //## @ingroup Process
   class MITKCORE_EXPORT ImageTimeSelector : public SubImageSelector
   {
   public:
     mitkClassMacro(ImageTimeSelector, SubImageSelector);
 
     itkFactorylessNewMacro(Self);
 
     itkCloneMacro(Self);
 
     itkGetConstMacro(TimeNr, int);
     itkSetMacro(TimeNr, int);
 
     itkGetConstMacro(ChannelNr, int);
     itkSetMacro(ChannelNr, int);
 
   protected:
     ImageTimeSelector();
 
     ~ImageTimeSelector() override;
 
     void GenerateOutputInformation() override;
 
     void GenerateInputRequestedRegion() override;
 
     void GenerateData() override;
 
     int m_TimeNr;
 
     int m_ChannelNr;
   };
 
+
+  /** Convenience helper that makes the application of the ImageTimeSelector one function call. It extracts the
+    image for the passed timestep, if the image has multiple time steps.
+    If a nullptr is passed as image, a nullptr will be retureed.
+    If an image without timesteps is passed, the image will be returned unaltered. The behavior of invalid time definition
+    is similar to the ImageTimeSelector filter.*/
+  MITKCORE_EXPORT Image::ConstPointer SelectImageByTimeStep(const Image* image, unsigned int timestep);
+  /** Non const version.*/
+  MITKCORE_EXPORT Image::Pointer SelectImageByTimeStep(Image* image, unsigned int timestep);
+  /** Convenience helper that makes the application of the ImageTimeSelector one function call. It extracts the
+    image for the passed time point, if the image has multiple time steps.
+    If a nullptr is passed as image, a nullptr will be returned.
+    If an image without timesteps is passed, the image will be returned unaltered. The behavior of invalid time definition
+    is similar to the ImageTimeSelector filter.*/
+  MITKCORE_EXPORT Image::ConstPointer SelectImageByTimePoint(const Image* image, TimePointType timePoint);
+  /** Non const version.*/
+  MITKCORE_EXPORT Image::Pointer SelectImageByTimePoint(Image* image, TimePointType timePoint);
+
 } // namespace mitk
 
 #endif /* IMAGETIMESELECTOR_H_HEADER_INCLUDED_C1E4861D */
diff --git a/Modules/Core/include/mitkImageVtkMapper2D.h b/Modules/Core/include/mitkImageVtkMapper2D.h
index 2128a21b7c..52d3efc792 100644
--- a/Modules/Core/include/mitkImageVtkMapper2D.h
+++ b/Modules/Core/include/mitkImageVtkMapper2D.h
@@ -1,321 +1,321 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKIMAGEVTKMAPPER2D_H_HEADER_INCLUDED_C10E906E
 #define MITKIMAGEVTKMAPPER2D_H_HEADER_INCLUDED_C10E906E
 
 // MITK
 #include <mitkCommon.h>
 
 // MITK Rendering
 #include "mitkBaseRenderer.h"
 #include "mitkExtractSliceFilter.h"
 #include "mitkVtkMapper.h"
 
 // VTK
 #include <vtkPropAssembly.h>
 #include <vtkSmartPointer.h>
 
 class vtkActor;
 class vtkPolyDataMapper;
 class vtkPlaneSource;
 class vtkImageData;
 class vtkLookupTable;
 class vtkImageExtractComponents;
 class vtkImageReslice;
 class vtkImageChangeInformation;
 class vtkPoints;
 class vtkMitkThickSlicesFilter;
 class vtkPolyData;
 class vtkMitkApplyLevelWindowToRGBFilter;
 class vtkMitkLevelWindowFilter;
 
 namespace mitk
 {
   /** \brief Mapper to resample and display 2D slices of a 3D image.
    *
    * The following image gives a brief overview of the mapping and the involved parts.
    *
    * \image html imageVtkMapper2Darchitecture.png
    *
    * First, the image is resliced by means of vtkImageReslice. The volume image
    * serves as input to the mapper in addition to spatial placement of the slice and a few other
    * properties such as thick slices. This code was already present in the old version
    * (mitkImageMapperGL2D).
    *
    * Next, the obtained slice (m_ReslicedImage) is put into a vtkMitkLevelWindowFilter
    * and the scalar levelwindow, opacity levelwindow and optional clipping to
    * local image bounds are applied
    *
    * Next, the output of the vtkMitkLevelWindowFilter is used to create a texture
    * (m_Texture) and a plane onto which the texture is rendered (m_Plane). For
    * mapping purposes, a vtkPolyDataMapper (m_Mapper) is utilized. Orthographic
    * projection is applied to create the effect of a 2D image. The mapper and the
    * texture are assigned to the actor (m_Actor) which is passed to the VTK rendering
    * pipeline via the method GetVtkProp().
    *
    * In order to transform the textured plane to the correct position in space, the
    * same transformation as used for reslicing is applied to both the camera and the
    * vtkActor. All important steps are explained in more detail below. The resulting
    * 2D image (by reslicing the underlying 3D input image appropriately) can either
    * be directly rendered in a 2D view or just be calculated to be used later by another
    * rendering entity, e.g. in texture mapping in a 3D view.
    *
    * Properties that can be set for images and influence the imageMapper2D are:
    *
    *   - \b "opacity": (FloatProperty) Opacity of the image
    *   - \b "color": (ColorProperty) Color of the image
    *   - \b "LookupTable": (mitkLookupTableProperty) If this property is set,
    *          the default lookuptable will be ignored and the "LookupTable" value
    *          will be used instead.
    *   - \b "Image Rendering.Mode": This property decides which mode is used to render images. (E.g. if a lookup table
    or
    a transferfunction is applied). Detailed documentation about the modes can be found here: \link
    mitk::RenderingModeProperty \endlink
    *   - \b "Image Rendering.Transfer Function": (mitkTransferFunctionProperty) If this
    *          property is set, a color transferfunction will be used to color the image.
    *   - \b "binary": (BoolProperty) is the image a binary image or not
    *   - \b "outline binary": (BoolProperty) show outline of the image or not
    *   - \b "texture interpolation": (BoolProperty) texture interpolation of the image
    *   - \b "reslice interpolation": (VtkResliceInterpolationProperty) reslice interpolation of the image
    *   - \b "in plane resample extent by geometry": (BoolProperty) Do it or not
    *   - \b "bounding box": (BoolProperty) Is the Bounding Box of the image shown or not
    *   - \b "layer": (IntProperty) Layer of the image
    *   - \b "volume annotation color": (ColorProperty) color of the volume annotation, TODO has to be reimplemented
    *   - \b "volume annotation unit": (StringProperty) annotation unit as string (does not implicit convert the unit!)
             unit is ml or cm3, TODO has to be reimplemented
 
    * The default properties are:
 
    *   - \b "opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite )
    *   - \b "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite )
    *   - \b "binary", mitk::BoolProperty::New( true ), renderer, overwrite )
    *   - \b "outline binary", mitk::BoolProperty::New( false ), renderer, overwrite )
    *   - \b "texture interpolation", mitk::BoolProperty::New( false ) )
    *   - \b "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() )
    *   - \b "in plane resample extent by geometry", mitk::BoolProperty::New( false ) )
    *   - \b "bounding box", mitk::BoolProperty::New( false ) )
    *   - \b "layer", mitk::IntProperty::New(10), renderer, overwrite)
    *   - \b "Image Rendering.Transfer Function":  Default color transfer function for CTs
    *   - \b "LookupTable": Rainbow color.
 
    * If the modality-property is set for an image, the mapper uses modality-specific default properties,
    * e.g. color maps, if they are defined.
 
    * \ingroup Mapper
    */
   class MITKCORE_EXPORT ImageVtkMapper2D : public VtkMapper
   {
   public:
     /** Standard class typedefs. */
     mitkClassMacro(ImageVtkMapper2D, VtkMapper);
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       /** \brief Get the Image to map */
       const mitk::Image *GetInput(void);
 
       /** \brief Checks whether this mapper needs to update itself and generate
      * data. */
     void Update(mitk::BaseRenderer *renderer) override;
 
     //### methods of MITK-VTK rendering pipeline
     vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;
     //### end of methods of MITK-VTK rendering pipeline
 
     /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
     /**
-       * To render transveral, coronal, and sagittal, the mapper is called three times.
+       * To render axial, coronal, and sagittal, the mapper is called three times.
        * For performance reasons, the corresponding data for each view is saved in the
        * internal helper class LocalStorage. This allows rendering n views with just
        * 1 mitkMapper using n vtkMapper.
        * */
     class MITKCORE_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
     {
     public:
       /** \brief Actor of the image in a 2D render window. */
       vtkSmartPointer<vtkActor> m_ImageActor;
       /** \brief Actor of the shadowimage in a 2D render window. */
       vtkSmartPointer<vtkActor> m_ShadowOutlineActor;
 
       /** Prop assembly containting everything for a regular display of the image.*/
       vtkSmartPointer<vtkPropAssembly> m_Actors;
       /** Prop assembly used if workspace is in an invalid state (e.g. invalid time point or
        * invalid world coordinate position is selected) and mapper has to "early out"
        * in Update() or GenerateDataForRenderer()*/
       vtkSmartPointer<vtkPropAssembly> m_EmptyActors;
       /** Prop assembly exposed publicly via ImagVtkMapper2D::GetVTKProp()*/
       vtkProp* m_PublicActors = nullptr;
 
       /** \brief Mapper of a 2D render window. */
       vtkSmartPointer<vtkPolyDataMapper> m_Mapper;
       vtkSmartPointer<vtkImageExtractComponents> m_VectorComponentExtractor;
       /** \brief Current slice of a 2D render window.*/
       vtkSmartPointer<vtkImageData> m_ReslicedImage;
       /** \brief Empty vtkPolyData that is set when rendering geometry does not
         *   intersect the image geometry.
         *   \warning This member variable is set to nullptr,
         *   if no image geometry is inside the plane geometry
         *   of the respective render window. Any user of this
         *   slice has to check whether it is set to nullptr!
         */
       vtkSmartPointer<vtkPolyData> m_EmptyPolyData;
       /** \brief Plane on which the slice is rendered as texture. */
       vtkSmartPointer<vtkPlaneSource> m_Plane;
       /** \brief The texture which is used to render the current slice. */
       vtkSmartPointer<vtkTexture> m_Texture;
       /** \brief The lookuptables for colors and level window */
       vtkSmartPointer<vtkLookupTable> m_DefaultLookupTable;
       vtkSmartPointer<vtkLookupTable> m_BinaryLookupTable;
       vtkSmartPointer<vtkLookupTable> m_ColorLookupTable;
       /** \brief The actual reslicer (one per renderer) */
       mitk::ExtractSliceFilter::Pointer m_Reslicer;
       /** \brief Filter for thick slices */
       vtkSmartPointer<vtkMitkThickSlicesFilter> m_TSFilter;
       /** \brief PolyData object containg all lines/points needed for outlining the contour.
             This container is used to save a computed contour for the next rendering execution.
             For instance, if you zoom or pann, there is no need to recompute the contour. */
       vtkSmartPointer<vtkPolyData> m_OutlinePolyData;
 
       /** \brief Timestamp of last update of stored data. */
       itk::TimeStamp m_LastUpdateTime;
 
       /** \brief mmPerPixel relation between pixel and mm. (World spacing).*/
       mitk::ScalarType *m_mmPerPixel;
 
       /** \brief This filter is used to apply the level window to Grayvalue and RBG(A) images. */
       vtkSmartPointer<vtkMitkLevelWindowFilter> m_LevelWindowFilter;
 
       /** \brief Default constructor of the local storage. */
       LocalStorage();
       /** \brief Default deconstructor of the local storage. */
       ~LocalStorage() override;
     };
 
     /** \brief Get the LocalStorage corresponding to the current renderer. */
     const LocalStorage *GetConstLocalStorage(mitk::BaseRenderer *renderer);
 
     /** \brief Set the default properties for general image rendering. */
     static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
 
     /** \brief This method switches between different rendering modes (e.g. use a lookup table or a transfer function).
      * Detailed documentation about the modes can be found here: \link mitk::RenderingModeProperty \endlink
      */
     void ApplyRenderingMode(mitk::BaseRenderer *renderer);
 
   protected:
     /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
     mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
     /** \brief Get the LocalStorage corresponding to the current renderer. */
     LocalStorage* GetLocalStorage(mitk::BaseRenderer* renderer);
 
     /** \brief Transforms the actor to the actual position in 3D.
       *   \param renderer The current renderer corresponding to the render window.
       */
     void TransformActor(mitk::BaseRenderer *renderer);
 
     /** \brief Generates a plane according to the size of the resliced image in milimeters.
       *
       * In VTK a vtkPlaneSource is defined through three points. The origin and two
       * points defining the axes of the plane (see VTK documentation). The origin is
       * set to (xMin; yMin; Z), where xMin and yMin are the minimal bounds of the
       * resliced image in space. Z is relevant for blending and the layer property.
       * The center of the plane (C) is also the center of the view plane (cf. the image above).
       *
       * \note For the standard MITK view with three 2D render windows showing three
       * different slices, three such planes are generated. All these planes are generated
       * in the XY-plane (even if they depict a YZ-slice of the volume).
       *
       */
     void GeneratePlane(mitk::BaseRenderer *renderer, double planeBounds[6]);
 
     /** \brief Generates a vtkPolyData object containing the outline of a given binary slice.
         \param renderer: Pointer to the renderer containing the needed information
         \note This code is based on code from the iil library.
         */
     template <typename TPixel>
     vtkSmartPointer<vtkPolyData> CreateOutlinePolyData(mitk::BaseRenderer *renderer);
 
     /** Default constructor */
     ImageVtkMapper2D();
     /** Default deconstructor */
     ~ImageVtkMapper2D() override;
 
     /** \brief Does the actual resampling, without rendering the image yet.
       * All the data is generated inside this method. The vtkProp (or Actor)
       * is filled with content (i.e. the resliced image).
       *
       * After generation, a 4x4 transformation matrix(t) of the current slice is obtained
       * from the vtkResliceImage object via GetReslicesAxis(). This matrix is
       * applied to each textured plane (actor->SetUserTransform(t)) to transform everything
       * to the actual 3D position (cf. the following image).
       *
       * \image html cameraPositioning3D.png
       *
       */
     void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
 
     /** \brief This method uses the vtkCamera clipping range and the layer property
       * to calcualte the depth of the object (e.g. image or contour). The depth is used
       * to keep the correct order for the final VTK rendering.*/
     float CalculateLayerDepth(mitk::BaseRenderer *renderer);
 
     /** \brief This method applies (or modifies) the lookuptable for all types of images.
      * \warning To use the lookup table, the property 'Lookup Table' must be set and a 'Image Rendering.Mode'
      * which uses the lookup table must be set.
   */
     void ApplyLookuptable(mitk::BaseRenderer *renderer);
 
     /** \brief This method applies a color transfer function.
      * Internally, a vtkColorTransferFunction is used. This is usefull for coloring continous
      * images (e.g. float)
      * \warning To use the color transfer function, the property 'Image Rendering.Transfer Function' must be set and a
      * 'Image Rendering.Mode' which uses the color transfer function must be set.
   */
     void ApplyColorTransferFunction(mitk::BaseRenderer *renderer);
 
     /**
      * @brief ApplyLevelWindow Apply the level window for the given renderer.
      * \warning To use the level window, the property 'LevelWindow' must be set and a 'Image Rendering.Mode' which uses
      * the level window must be set.
      * @param renderer Level window for which renderer?
      */
     void ApplyLevelWindow(mitk::BaseRenderer *renderer);
 
     /** \brief Set the color of the image/polydata */
     void ApplyColor(mitk::BaseRenderer *renderer);
 
     /** \brief Set the opacity of the actor. */
     void ApplyOpacity(mitk::BaseRenderer *renderer);
 
     /**
       * \brief Calculates whether the given rendering geometry intersects the
       * given SlicedGeometry3D.
       *
       * This method checks if the given PlaneGeometry intersects the given
       * SlicedGeometry3D. It calculates the distance of the PlaneGeometry to all
       * 8 cornerpoints of the SlicedGeometry3D. If all distances have the same
       * sign (all positive or all negative) there is no intersection.
       * If the distances have different sign, there is an intersection.
       **/
     bool RenderingGeometryIntersectsImage(const PlaneGeometry *renderingGeometry, SlicedGeometry3D *imageGeometry);
 
     /** Helper function to reset the local storage in order to indicate an invalid state.*/
     void SetToInvalidState(mitk::ImageVtkMapper2D::LocalStorage* localStorage);
   };
 
 } // namespace mitk
 
 #endif /* MITKIMAGEVTKMAPPER2D_H_HEADER_INCLUDED_C10E906E */
diff --git a/Modules/Core/include/mitkPlaneGeometry.h b/Modules/Core/include/mitkPlaneGeometry.h
index 7e61246ac8..c160a76632 100644
--- a/Modules/Core/include/mitkPlaneGeometry.h
+++ b/Modules/Core/include/mitkPlaneGeometry.h
@@ -1,614 +1,614 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /**
 * \brief Describes the geometry of a plane object
 *
 * Describes a two-dimensional manifold, i.e., to put it simply,
 * an object that can be described using a 2D coordinate-system.
 *
 * PlaneGeometry can map points between 3D world coordinates
 * (in mm) and the described 2D coordinate-system (in mm) by first projecting
 * the 3D point onto the 2D manifold and then calculating the 2D-coordinates
 * (in mm). These 2D-mm-coordinates can be further converted into
 * 2D-unit-coordinates (e.g., pixels), giving a parameter representation of
 * the object with parameter values inside a rectangle
 * (e.g., [0,0]..[width, height]), which is the bounding box (bounding range
 * in z-direction always [0]..[1]).
 *
 * A PlaneGeometry describes the 2D representation within a 3D object (derived from BaseGeometry). For example,
 * a single CT-image (slice) is 2D in the sense that you can access the
 * pixels using 2D-coordinates, but is also 3D, as the pixels are really
 * voxels, thus have an extension (thickness) in the 3rd dimension.
 *
 *
 * Optionally, a reference BaseGeometry can be specified, which usually would
 * be the geometry associated with the underlying dataset. This is currently
 * used for calculating the intersection of inclined / rotated planes
 * (represented as PlaneGeometry) with the bounding box of the associated
 * BaseGeometry.
 *
 * \warning The PlaneGeometry are not necessarily up-to-date and not even
 * initialized. As described in the previous paragraph, one of the
 * Generate-/Copy-/UpdateOutputInformation methods have to initialize it.
 * mitk::BaseData::GetPlaneGeometry() makes sure, that the PlaneGeometry is
 * up-to-date before returning it (by setting the update extent appropriately
 * and calling UpdateOutputInformation).
 *
 * Rule: everything is in mm (or ms for temporal information) if not
 * stated otherwise.
 * \ingroup Geometry
 */
 
 #ifndef PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
 #define PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
 
 #include "mitkBaseGeometry.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include <MitkCoreExports.h>
 
 #include <vnl/vnl_cross.h>
 
 namespace mitk
 {
   template <class TCoordRep, unsigned int NPointDimension>
   class Line;
   typedef Line<ScalarType, 3> Line3D;
 
   class PlaneGeometry;
   /** \deprecatedSince{2014_10} This class is deprecated. Please use PlaneGeometry instead. */
   DEPRECATED(typedef PlaneGeometry Geometry2D);
 
   /**
   * \brief Describes a two-dimensional, rectangular plane
   *
   * \ingroup Geometry
   */
   class MITKCORE_EXPORT PlaneGeometry : public BaseGeometry
   {
   public:
     mitkClassMacro(PlaneGeometry, BaseGeometry);
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       enum PlaneOrientation {
         Axial,
         Sagittal,
-        Frontal, // also known as "Coronal" in mitk.
+        Coronal,
         None     // This defines the PlaneGeometry for the 3D renderWindow which
         // curiously also needs a PlaneGeometry. This should be reconsidered some time.
       };
 
     virtual void IndexToWorld(const Point2D &pt_units, Point2D &pt_mm) const;
 
     virtual void WorldToIndex(const Point2D &pt_mm, Point2D &pt_units) const;
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## @deprecated First parameter (Point2D) is not used. If possible, please use void IndexToWorld(const
     // mitk::Vector2D& vec_units, mitk::Vector2D& vec_mm) const.
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void IndexToWorld(const mitk::Point2D &atPt2d_untis,
                               const mitk::Vector2D &vec_units,
                               mitk::Vector2D &vec_mm) const;
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void IndexToWorld(const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## @deprecated First parameter (Point2D) is not used. If possible, please use void WorldToIndex(const
     // mitk::Vector2D& vec_mm, mitk::Vector2D& vec_units) const.
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void WorldToIndex(const mitk::Point2D &atPt2d_mm,
                               const mitk::Vector2D &vec_mm,
                               mitk::Vector2D &vec_units) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## For further information about coordinates types, please see the Geometry documentation
     virtual void WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
 
     /**
     * \brief Initialize a plane with orientation \a planeorientation
     * (default: axial) with respect to \a BaseGeometry (default: identity).
     * Spacing also taken from \a BaseGeometry.
     *
     * \warning A former version of this method created a geometry with unit
     * spacing. For unit spacing use
     *
     * \code
     *   // for in-plane unit spacing:
     *   thisgeometry->SetSizeInUnits(thisgeometry->GetExtentInMM(0),
     *     thisgeometry->GetExtentInMM(1));
     *   // additionally, for unit spacing in normal direction (former version
     *   // did not do this):
     *   thisgeometry->SetExtentInMM(2, 1.0);
     * \endcode
     */
     virtual void InitializeStandardPlane(const BaseGeometry *geometry3D,
                                          PlaneOrientation planeorientation = Axial,
                                          ScalarType zPosition = 0,
                                          bool frontside = true,
                                          bool rotated = false,
                                          bool top = true);
 
     /**
     * \brief Initialize a plane with orientation \a planeorientation
     * (default: axial) with respect to \a BaseGeometry (default: identity).
     * Spacing also taken from \a BaseGeometry.
     *
     * \param geometry3D
     * \param top if \a true, create plane at top, otherwise at bottom
     * (for PlaneOrientation Axial, for other plane locations respectively)
     * \param planeorientation
     * \param frontside
     * \param rotated
     */
     virtual void InitializeStandardPlane(const BaseGeometry *geometry3D,
                                          bool top,
                                          PlaneOrientation planeorientation = Axial,
                                          bool frontside = true,
                                          bool rotated = false);
 
     /**
     * \brief Initialize a plane with orientation \a planeorientation
     * (default: axial) with respect to \a transform (default: identity)
     * given width and height in units.
     *
     * \a Rotated means rotated by 180 degrees (1/2 rotation) within the plane.
     * Rotation by 90 degrees (1/4 rotation) is not implemented as of now.
     *
     * \a Frontside/Backside:
     * Viewed from below = frontside in the axial case;
     * (radiologist's view versus neuro-surgeon's view, see:
     * http://www.itk.org/Wiki/images/e/ed/DICOM-OrientationDiagram-Radiologist-vs-NeuroSurgeon.png )
     * Viewed from front = frontside in the coronal case;
     * Viewed from left = frontside in the sagittal case.
     *
     * \a Cave/Caution: Currently only RPI, LAI, LPS and RAS in the three standard planes are covered,
     * i.e. 12 cases of 144:  3 standard planes * 48 coordinate orientations = 144 cases.
     */
     virtual void InitializeStandardPlane(ScalarType width,
                                          ScalarType height,
                                          const AffineTransform3D *transform = nullptr,
                                          PlaneOrientation planeorientation = Axial,
                                          ScalarType zPosition = 0,
                                          bool frontside = true,
                                          bool rotated = false,
                                          bool top = true);
 
     /**
     * \brief Initialize plane with orientation \a planeorientation
     * (default: axial) given width, height and spacing.
     *
     */
     virtual void InitializeStandardPlane(ScalarType width,
                                          ScalarType height,
                                          const Vector3D &spacing,
                                          PlaneOrientation planeorientation = Axial,
                                          ScalarType zPosition = 0,
                                          bool frontside = true,
                                          bool rotated = false,
                                          bool top = true);
 
     /**
     * \brief Initialize plane by width and height in pixels, right-/down-vector
     * (itk) to describe orientation in world-space (vectors will be normalized)
     * and spacing (default: 1.0 mm in all directions).
     *
     * The vectors are normalized and multiplied by the respective spacing before
     * they are set in the matrix.
     *
     * This overloaded version of InitializeStandardPlane() creates only righthanded
     * coordinate orientations, unless spacing contains 1 or 3 negative entries.
     *
     */
     virtual void InitializeStandardPlane(ScalarType width,
                                          ScalarType height,
                                          const Vector3D &rightVector,
                                          const Vector3D &downVector,
                                          const Vector3D *spacing = nullptr);
 
     /**
     * \brief Initialize plane by width and height in pixels,
     * right-/down-vector (vnl) to describe orientation in world-space (vectors
     * will be normalized) and spacing (default: 1.0 mm in all directions).
     *
     * The vectors are normalized and multiplied by the respective spacing
     * before they are set in the matrix.
     *
     * This overloaded version of InitializeStandardPlane() creates only righthanded
     * coordinate orientations, unless spacing contains 1 or 3 negative entries.
     *
     */
     virtual void InitializeStandardPlane(ScalarType width,
                                          ScalarType height,
                                          const VnlVector &rightVector,
                                          const VnlVector &downVector,
                                          const Vector3D *spacing = nullptr);
 
     /**
     * \brief Initialize plane by right-/down-vector (itk) and spacing
     * (default: 1.0 mm in all directions).
     *
     * The length of the right-/-down-vector is used as width/height in units,
     * respectively. Then, the vectors are normalized and multiplied by the
     * respective spacing before they are set in the matrix.
     */
     virtual void InitializeStandardPlane(const Vector3D &rightVector,
                                          const Vector3D &downVector,
                                          const Vector3D *spacing = nullptr);
 
     /**
     * \brief Initialize plane by right-/down-vector (vnl) and spacing
     * (default: 1.0 mm in all directions).
     *
     * The length of the right-/-down-vector is used as width/height in units,
     * respectively. Then, the vectors are normalized and multiplied by the
     * respective spacing before they are set in the matrix.
     */
     virtual void InitializeStandardPlane(const VnlVector &rightVector,
                                          const VnlVector &downVector,
                                          const Vector3D *spacing = nullptr);
 
     /**
     * \brief Initialize plane by origin and normal (size is 1.0 mm in
     * all directions, direction of right-/down-vector valid but
     * undefined).
     * \warning This function can only produce righthanded coordinate orientation, not lefthanded.
     */
     virtual void InitializePlane(const Point3D &origin, const Vector3D &normal);
 
     /**
     * \brief Initialize plane by right-/down-vector.
     *
     * \warning The vectors are set into the matrix as they are,
     * \em without normalization!
     * This function creates a righthanded IndexToWorldTransform,
     * only a negative thickness could still make it lefthanded.
     */
     void SetMatrixByVectors(const VnlVector &rightVector, const VnlVector &downVector, ScalarType thickness = 1.0);
 
     /**
     * \brief Check if matrix is a rotation matrix:
     * - determinant is 1?
     * - R*R^T is ID?
     * Output warning otherwise.
     */
     static bool CheckRotationMatrix(AffineTransform3D *transform, double epsilon=1e-6);
 
     /**
     * \brief Normal of the plane
     *
     */
     Vector3D GetNormal() const;
 
     /**
     * \brief Normal of the plane as VnlVector
     *
     */
     VnlVector GetNormalVnl() const;
 
     virtual ScalarType SignedDistance(const Point3D &pt3d_mm) const;
 
     /**
     * \brief Calculates, whether a point is below or above the plane. There are two different
     *calculation methods, with or without consideration of the bounding box.
     */
     virtual bool IsAbove(const Point3D &pt3d_mm, bool considerBoundingBox = false) const;
 
     /**
     * \brief Distance of the point from the plane
     * (bounding-box \em not considered)
     *
     */
     ScalarType DistanceFromPlane(const Point3D &pt3d_mm) const;
 
     /**
     * \brief Signed distance of the point from the plane
     * (bounding-box \em not considered)
     *
     * > 0 : point is in the direction of the direction vector.
     */
     inline ScalarType SignedDistanceFromPlane(const Point3D &pt3d_mm) const
     {
       ScalarType len = GetNormalVnl().two_norm();
 
       if (len == 0)
         return 0;
 
       return (pt3d_mm - GetOrigin()) * GetNormal() / len;
     }
 
     /**
     * \brief Distance of the plane from another plane
     * (bounding-box \em not considered)
     *
     * Result is 0 if planes are not parallel.
     */
     ScalarType DistanceFromPlane(const PlaneGeometry *plane) const { return fabs(SignedDistanceFromPlane(plane)); }
     /**
     * \brief Signed distance of the plane from another plane
     * (bounding-box \em not considered)
     *
     * Result is 0 if planes are not parallel.
     */
     inline ScalarType SignedDistanceFromPlane(const PlaneGeometry *plane) const
     {
       if (IsParallel(plane))
       {
         return SignedDistance(plane->GetOrigin());
       }
       return 0;
     }
 
     /**
     * \brief Calculate the intersecting line of two planes
     *
     * \return \a true planes are intersecting
     * \return \a false planes do not intersect
     */
     bool IntersectionLine(const PlaneGeometry *plane, Line3D &crossline) const;
 
     /**
     * \brief Calculate two points where another plane intersects the border of this plane
     *
     * \return number of intersection points (0..2). First interection point (if existing)
     * is returned in \a lineFrom, second in \a lineTo.
     */
     unsigned int IntersectWithPlane2D(const PlaneGeometry *plane, Point2D &lineFrom, Point2D &lineTo) const;
 
     /**
     * \brief Calculate the angle between two planes
     *
     * \return angle in radiants
     */
     double Angle(const PlaneGeometry *plane) const;
 
     /**
     * \brief Calculate the angle between the plane and a line
     *
     * \return angle in radiants
     */
     double Angle(const Line3D &line) const;
 
     /**
     * \brief Calculate intersection point between the plane and a line
     *
     * \param line
     * \param intersectionPoint intersection point
     * \return \a true if \em unique intersection exists, i.e., if line
     * is \em not on or parallel to the plane
     */
     bool IntersectionPoint(const Line3D &line, Point3D &intersectionPoint) const;
 
     /**
     * \brief Calculate line parameter of intersection point between the
     * plane and a line
     *
     * \param line
     * \param t parameter of line: intersection point is
     * line.GetPoint()+t*line.GetDirection()
     * \return \a true if \em unique intersection exists, i.e., if line
     * is \em not on or parallel to the plane
     */
     bool IntersectionPointParam(const Line3D &line, double &t) const;
 
     /**
     * \brief Returns whether the plane is parallel to another plane
     *
     * @return true iff the normal vectors both point to the same or exactly oposit direction
     */
     bool IsParallel(const PlaneGeometry *plane) const;
 
     /**
     * \brief Returns whether the point is on the plane
     * (bounding-box \em not considered)
     */
     bool IsOnPlane(const Point3D &point) const;
 
     /**
     * \brief Returns whether the line is on the plane
     * (bounding-box \em not considered)
     */
     bool IsOnPlane(const Line3D &line) const;
 
     /**
     * \brief Returns whether the plane is on the plane
     * (bounding-box \em not considered)
     *
     * @return true if the normal vector of the planes point to the same or the exactly oposit direction and
     *  the distance of the planes is < eps
     *
     */
     bool IsOnPlane(const PlaneGeometry *plane) const;
 
     /**
     * \brief Returns the lot from the point to the plane
     */
     Point3D ProjectPointOntoPlane(const Point3D &pt) const;
 
     itk::LightObject::Pointer InternalClone() const override;
 
     /** Implements operation to re-orient the plane */
     void ExecuteOperation(Operation *operation) override;
 
     /**
     * \brief Project a 3D point given in mm (\a pt3d_mm) onto the 2D
     * geometry. The result is a 2D point in mm (\a pt2d_mm).
     *
     * The result is a 2D point in mm (\a pt2d_mm) relative to the upper-left
     * corner of the geometry. To convert this point into units (e.g., pixels
     * in case of an image), use WorldToIndex.
     * \return true projection was possible
     * \sa Project(const mitk::Point3D &pt3d_mm, mitk::Point3D
     * &projectedPt3d_mm)
     */
     virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const;
 
     /**
     * \brief Converts a 2D point given in mm (\a pt2d_mm) relative to the
     * upper-left corner of the geometry into the corresponding
     * world-coordinate (a 3D point in mm, \a pt3d_mm).
     *
     * To convert a 2D point given in units (e.g., pixels in case of an
     * image) into a 2D point given in mm (as required by this method), use
     * IndexToWorld.
     */
     virtual void Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const;
 
     /**
     * \brief Set the width and height of this 2D-geometry in units by calling
     * SetBounds. This does \a not change the extent in mm!
     *
     * For an image, this is the number of pixels in x-/y-direction.
     * \note In contrast to calling SetBounds directly, this does \a not change
     * the extent in mm!
     */
     virtual void SetSizeInUnits(mitk::ScalarType width, mitk::ScalarType height);
 
     /**
     * \brief Project a 3D point given in mm (\a pt3d_mm) onto the 2D
     * geometry. The result is a 3D point in mm (\a projectedPt3d_mm).
     *
     * \return true projection was possible
     */
     virtual bool Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const;
 
     /**
     * \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
     * geometry. The result is a 2D vector in mm (\a vec2d_mm).
     *
     * The result is a 2D vector in mm (\a vec2d_mm) relative to the
     * upper-left
     * corner of the geometry. To convert this point into units (e.g., pixels
     * in case of an image), use WorldToIndex.
     * \return true projection was possible
     * \sa Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D
     * &projectedVec3d_mm)
     */
     virtual bool Map(const mitk::Point3D &atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const;
 
     /**
     * \brief Converts a 2D vector given in mm (\a vec2d_mm) relative to the
     * upper-left corner of the geometry into the corresponding
     * world-coordinate (a 3D vector in mm, \a vec3d_mm).
     *
     * To convert a 2D vector given in units (e.g., pixels in case of an
     * image) into a 2D vector given in mm (as required by this method), use
     * IndexToWorld.
     */
     virtual void Map(const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const;
 
     /**
     * \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
     * geometry. The result is a 3D vector in mm (\a projectedVec3d_mm).
     *
     * DEPRECATED. Use Project(vector,vector) instead
     *
     * \return true projection was possible
     */
     virtual bool Project(const mitk::Point3D &atPt3d_mm,
                          const mitk::Vector3D &vec3d_mm,
                          mitk::Vector3D &projectedVec3d_mm) const;
 
     /**
     * \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
     * geometry. The result is a 3D vector in mm (\a projectedVec3d_mm).
     *
     * \return true projection was possible
     */
     virtual bool Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
 
     /**
     * \brief Distance of the point from the geometry
     * (bounding-box \em not considered)
     *
     */
     inline ScalarType Distance(const Point3D &pt3d_mm) const { return fabs(SignedDistance(pt3d_mm)); }
     /**
     * \brief Set the geometrical frame of reference in which this PlaneGeometry
     * is placed.
     *
     * This would usually be the BaseGeometry of the underlying dataset, but
     * setting it is optional.
     */
     void SetReferenceGeometry(const mitk::BaseGeometry *geometry);
 
     /**
     * \brief Get the geometrical frame of reference for this PlaneGeometry.
     */
     const BaseGeometry *GetReferenceGeometry() const;
     bool HasReferenceGeometry() const;
 
     static std::vector< int > CalculateDominantAxes(mitk::AffineTransform3D::MatrixType::InternalMatrixType& rotation_matrix);
 
   protected:
     PlaneGeometry();
 
     PlaneGeometry(const PlaneGeometry &other);
 
     ~PlaneGeometry() override;
 
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
     const mitk::BaseGeometry *m_ReferenceGeometry;
 
     //##Documentation
     //## @brief PreSetSpacing
     //##
     //## These virtual function allows a different beahiour in subclasses.
     //## Do implement them in every subclass of BaseGeometry. If not needed, use
     //## {Superclass::PreSetSpacing();};
     void PreSetSpacing(const mitk::Vector3D &aSpacing) override { Superclass::PreSetSpacing(aSpacing); };
     //##Documentation
     //## @brief CheckBounds
     //##
     //## This function is called in SetBounds. Assertions can be implemented in this function (see PlaneGeometry.cpp).
     //## If you implement this function in a subclass, make sure, that all classes were your class inherits from
     //## have an implementation of CheckBounds
     //## (e.g. inheritance BaseGeometry <- A <- B. Implementation of CheckBounds in class B needs implementation in A as
     // well!)
     void CheckBounds(const BoundsArrayType &bounds) override;
 
     //##Documentation
     //## @brief CheckIndexToWorldTransform
     //##
     //## This function is called in SetIndexToWorldTransform. Assertions can be implemented in this function (see
     // PlaneGeometry.cpp).
     //## In Subclasses of BaseGeometry, implement own conditions or call Superclass::CheckBounds(bounds);.
     void CheckIndexToWorldTransform(mitk::AffineTransform3D *transform) override;
 
   private:
     /**
     * \brief Compares plane with another plane: \a true if IsOnPlane
     * (bounding-box \em not considered)
     */
     virtual bool operator==(const PlaneGeometry *) const { return false; };
     /**
     * \brief Compares plane with another plane: \a false if IsOnPlane
     * (bounding-box \em not considered)
     */
     virtual bool operator!=(const PlaneGeometry *) const { return false; };
   };
 } // namespace mitk
 
 #endif /* PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Modules/Core/include/mitkPointSetVtkMapper2D.h b/Modules/Core/include/mitkPointSetVtkMapper2D.h
index 31f3cfdced..def499c1c9 100644
--- a/Modules/Core/include/mitkPointSetVtkMapper2D.h
+++ b/Modules/Core/include/mitkPointSetVtkMapper2D.h
@@ -1,239 +1,239 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkPointSetVtkMapper2D_h
 #define mitkPointSetVtkMapper2D_h
 
 #include "mitkBaseRenderer.h"
 #include "mitkLocalStorageHandler.h"
 #include "mitkVtkMapper.h"
 #include <MitkCoreExports.h>
 #include <mitkPointSetShapeProperty.h>
 
 // VTK
 #include <vtkSmartPointer.h>
 class vtkActor;
 class vtkPropAssembly;
 class vtkPolyData;
 class vtkPolyDataMapper;
 class vtkGlyphSource2D;
 class vtkGlyph3D;
 class vtkFloatArray;
 class vtkCellArray;
 
 namespace mitk
 {
   class PointSet;
 
   /**
   * @brief Vtk-based 2D mapper for PointSet
   *
   * Due to the need of different colors for selected
   * and unselected points and the facts, that we also have a contour and
   * labels for the points, the vtk structure is build up the following way:
   *
   * We have three PolyData, one selected, and one unselected and one
   * for a contour between the points. Each one is connected to an own
   * PolyDataMapper and an Actor. The different color for the unselected and
   * selected state and for the contour is read from properties.
   *
   * This mapper has several additional functionalities, such as rendering
   * a contour between points, calculating and displaying distances or angles
   * between points.
   *
   * @section mitkPointSetVtkMapper2D_point_rep Point Representation
   *
   * The points are displayed as small glyphs of configurable shape
   * (see property "PointSet.2D.shape"). The size of these glyphs
   * is given in world units. That means, the size or shape of those
   * glyphs is independent of the BaseGeometry object that you assign
   * to the PointSet. As for all other objects, _positions_ of points
   * will be transformed into the world via the Geometry's index-to-world
   * transform.
   *
   * Then the three Actors are combined inside a vtkPropAssembly and this
   * object is returned in GetProp() and so hooked up into the rendering
   * pipeline.
   *
   * @section mitkPointSetVtkMapper2D_propertires Applicable Properties
   *
   * Properties that can be set for point sets and influence the PointSetVTKMapper2D are:
   *
   *   - \b "line width": (IntProperty 2)                      // line width of the line from one point to another
   *   - \b "point line width": (IntProperty 1)                // line width of the cross marking a point
   *   - \b "point 2D size": (FloatProperty 6)                 // size of the glyph marking a point (diameter, in world
   * units!)
   *   - \b "show contour": (BoolProperty false)               // enable contour rendering between points (lines)
   *   - \b "close contour": (BoolProperty false)              // if enabled, the open strip is closed (first point
   * connected with last point)
   *   - \b "show points": (BoolProperty true)                 // show or hide points
   *   - \b "show distances": (BoolProperty false)             // show or hide distance measure
   *   - \b "distance decimal digits": (IntProperty 2)         // set the number of decimal digits to be shown when
   * rendering the distance information
   *   - \b "show angles": (BoolProperty false)                // show or hide angle measurement
   *   - \b "show distant lines": (BoolProperty false)         // show the line between to points from a distant view
   * (equals "always on top" option)
   *   - \b "layer": (IntProperty 1)                           // default is drawing pointset above images (they have a
   * default layer of 0)
   *   - \b "PointSet.2D.shape" (EnumerationProperty Cross)    // provides different shapes marking a point
   *       0 = "None", 1 = "Vertex", 2 = "Dash", 3 = "Cross", 4 = "ThickCross", 5 = "Triangle", 6 = "Square", 7 =
   * "Circle",
   *       8 = "Diamond", 9 = "Arrow", 10 = "ThickArrow", 11 = "HookedArrow", 12 = "Cross"
   *   - \b "PointSet.2D.fill shape": (BoolProperty false)     // fill or do not fill the glyph shape
   *   - \b "Pointset.2D.distance to plane": (FloatProperty 4.0) //In the 2D render window, points are rendered which lie
   * within a certain distance
   *                                                             to the current plane. They are projected on the current
   * plane and scaled according to their distance.
   *                                                             Point markers appear smaller as the plane moves away
   * from
   * their true location.
   *                                                             The distance threshold can be adjusted by this float
   * property, which ables the user to delineate the points
   *                                                             that lie exactly on the plane. (+/- rounding error)
   *
   * Other Properties used here but not defined in this class:
   *
   *   - \b "selectedcolor": (ColorProperty (1.0f, 0.0f, 0.0f))  // default color of the selected pointset e.g. the
   * current
   * point is red
   *   - \b "contourcolor" : (ColorProperty (1.0f, 0.0f, 0.0f))  // default color for the contour is red
   *   - \b "color": (ColorProperty (1.0f, 1.0f, 0.0f))          // default color of the (unselected) pointset is yellow
   *   - \b "opacity": (FloatProperty 1.0)                       // opacity of point set, contours
   *   - \b "label": (StringProperty nullptr)     // a label can be defined for each point, which is rendered in proximity
   * to
   * the point
   *
   * @ingroup Mapper
   */
   class MITKCORE_EXPORT PointSetVtkMapper2D : public VtkMapper
   {
   public:
     mitkClassMacro(PointSetVtkMapper2D, VtkMapper);
 
     itkFactorylessNewMacro(Self);
 
     itkCloneMacro(Self);
 
       virtual const mitk::PointSet *GetInput() const;
 
     /** \brief returns the a prop assembly */
     vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;
 
     /** \brief set the default properties for this mapper */
     static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
 
     /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
     class LocalStorage : public mitk::Mapper::BaseLocalStorage
     {
     public:
       /* constructor */
       LocalStorage();
 
       /* destructor */
       ~LocalStorage() override;
 
       // points
       vtkSmartPointer<vtkPoints> m_UnselectedPoints;
       vtkSmartPointer<vtkPoints> m_SelectedPoints;
       vtkSmartPointer<vtkPoints> m_ContourPoints;
 
       // scales
       vtkSmartPointer<vtkFloatArray> m_UnselectedScales;
       vtkSmartPointer<vtkFloatArray> m_SelectedScales;
 
       // distances
       vtkSmartPointer<vtkFloatArray> m_DistancesBetweenPoints;
 
       // lines
       vtkSmartPointer<vtkCellArray> m_ContourLines;
 
       // glyph source (provides different shapes for the points)
       vtkSmartPointer<vtkGlyphSource2D> m_UnselectedGlyphSource2D;
       vtkSmartPointer<vtkGlyphSource2D> m_SelectedGlyphSource2D;
 
       // glyph
       vtkSmartPointer<vtkGlyph3D> m_UnselectedGlyph3D;
       vtkSmartPointer<vtkGlyph3D> m_SelectedGlyph3D;
 
       // polydata
       vtkSmartPointer<vtkPolyData> m_VtkUnselectedPointListPolyData;
       vtkSmartPointer<vtkPolyData> m_VtkSelectedPointListPolyData;
       vtkSmartPointer<vtkPolyData> m_VtkContourPolyData;
 
       // actor
       vtkSmartPointer<vtkActor> m_UnselectedActor;
       vtkSmartPointer<vtkActor> m_SelectedActor;
       vtkSmartPointer<vtkActor> m_ContourActor;
       vtkSmartPointer<vtkTextActor> m_VtkTextActor;
 
       std::vector<vtkSmartPointer<vtkTextActor>> m_VtkTextLabelActors;
       std::vector<vtkSmartPointer<vtkTextActor>> m_VtkTextDistanceActors;
       std::vector<vtkSmartPointer<vtkTextActor>> m_VtkTextAngleActors;
 
       // mappers
       vtkSmartPointer<vtkPolyDataMapper> m_VtkUnselectedPolyDataMapper;
       vtkSmartPointer<vtkPolyDataMapper> m_VtkSelectedPolyDataMapper;
       vtkSmartPointer<vtkPolyDataMapper> m_VtkContourPolyDataMapper;
 
       // propassembly
       vtkSmartPointer<vtkPropAssembly> m_PropAssembly;
     };
 
     /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
     mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
   protected:
     /* constructor */
     PointSetVtkMapper2D();
 
     /* destructor */
     ~PointSetVtkMapper2D() override;
 
     /* \brief Applies the color and opacity properties and calls CreateVTKRenderObjects */
     void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
     /* \brief Called in mitk::Mapper::Update
     * If TimeGeometry or time step is not valid of point set: reset mapper so that nothing is
     * displayed e.g. toggle visiblity of the propassembly */
     void ResetMapper(BaseRenderer *renderer) override;
 
     /* \brief Fills the vtk objects, thus it is only called when the point set has been changed.
    * This function iterates over the input point set and determines the glyphs which lie in a specific
    * range around the current slice. Those glyphs are rendered using a specific shape defined in vtk glyph source
    * to mark each point. The shape can be changed in MITK using the property "PointSet.2D.shape".
    *
    * There were issues when rendering vtk glyphs in the 2D-render windows. By default, the glyphs are
    * rendered within the x-y plane in each 2D-render window, so you would only see them from the
-   * side in the saggital and coronal 2D-render window. The solution to this is to rotate the glyphs in order
+   * side in the sagittal and coronal 2D-render window. The solution to this is to rotate the glyphs in order
    * to be ortogonal to the current view vector. To achieve this, the rotation (vtktransform) of the current
    * PlaneGeometry is applied to the orienation of the glyphs. */
     virtual void CreateVTKRenderObjects(mitk::BaseRenderer *renderer);
 
     // member variables holding the current value of the properties used in this mapper
     bool m_ShowContour;           // "show contour" property
     bool m_CloseContour;          // "close contour" property
     bool m_ShowPoints;            // "show points" property
     bool m_ShowDistances;         // "show distances" property
     int m_DistancesDecimalDigits; // "distance decimal digits" property
     bool m_ShowAngles;            // "show angles" property
     bool m_ShowDistantLines;      // "show distant lines" property
     int m_LineWidth;              // "line width" property
     int m_PointLineWidth;         // "point line width" property
     float m_Point2DSize;          // "point 2D size" property
     int m_IDShapeProperty;        // ID for mitkPointSetShape Enumeration Property "Pointset.2D.shape"
     bool m_FillShape;             // "Pointset.2D.fill shape" property
     float m_DistanceToPlane;      // "Pointset.2D.distance to plane" property
     bool m_FixedSizeOnScreen;     // "Pointset.2D.fixed size on screen" property
   };
 
 } // namespace mitk
 
 #endif /* mitkPointSetVtkMapper2D_h */
diff --git a/Modules/Core/include/mitkSliceNavigationController.h b/Modules/Core/include/mitkSliceNavigationController.h
index 113f51cdd1..9b262c68e0 100644
--- a/Modules/Core/include/mitkSliceNavigationController.h
+++ b/Modules/Core/include/mitkSliceNavigationController.h
@@ -1,472 +1,472 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F
 #define SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F
 
 #include "mitkBaseController.h"
 #include "mitkMessage.h"
 #include "mitkRenderingManager.h"
 #include "mitkTimeGeometry.h"
 #include <MitkCoreExports.h>
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 #include "mitkDataStorage.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include <itkCommand.h>
 #include <sstream>
 
 namespace mitk
 {
 #define mitkTimeGeometryEventMacro(classname, super)                                                                   \
   class MITKCORE_EXPORT classname : public super                                                                       \
   {                                                                                                                    \
   public:                                                                                                              \
     typedef classname Self;                                                                                            \
     typedef super Superclass;                                                                                          \
     classname(TimeGeometry *aTimeGeometry, unsigned int aPos) : Superclass(aTimeGeometry, aPos) {}                     \
     virtual ~classname() {}                                                                                            \
     virtual const char *GetEventName() const { return #classname; }                                                    \
     virtual bool CheckEvent(const ::itk::EventObject *e) const { return dynamic_cast<const Self *>(e); }               \
     virtual ::itk::EventObject *MakeObject() const { return new Self(GetTimeGeometry(), GetPos()); }                   \
   private:                                                                                                             \
     void operator=(const Self &);                                                                                      \
   }
 
   class PlaneGeometry;
   class BaseGeometry;
   class BaseRenderer;
 
   /**
    * \brief Controls the selection of the slice the associated BaseRenderer
    * will display
    *
    * A SliceNavigationController takes a BaseGeometry or a TimeGeometry as input world geometry
    * (TODO what are the exact requirements?) and generates a TimeGeometry
    * as output. The TimeGeometry holds a number of SlicedGeometry3Ds and
    * these in turn hold a series of PlaneGeometries. One of these PlaneGeometries is
    * selected as world geometry for the BaseRenderers associated to 2D views.
    *
    * The SliceNavigationController holds has Steppers (one for the slice, a
    * second for the time step), which control the selection of a single
    * PlaneGeometry from the TimeGeometry. SliceNavigationController generates
    * ITK events to tell observers, like a BaseRenderer,  when the selected slice
    * or timestep changes.
    *
    * Example:
    * \code
    * // Initialization
    * sliceCtrl = mitk::SliceNavigationController::New();
    *
    * // Tell the navigator the geometry to be sliced (with geometry a
    * // BaseGeometry::ConstPointer)
    * sliceCtrl->SetInputWorldGeometry3D(geometry.GetPointer());
    *
    * // Tell the navigator in which direction it shall slice the data
    * sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Axial);
    *
    * // Connect one or more BaseRenderer to this navigator, i.e.: events sent
    * // by the navigator when stepping through the slices (e.g. by
    * // sliceCtrl->GetSlice()->Next()) will be received by the BaseRenderer
    * // (in this example only slice-changes, see also ConnectGeometryTimeEvent
    * // and ConnectGeometryEvents.)
    * sliceCtrl->ConnectGeometrySliceEvent(renderer.GetPointer());
    *
    * //create a world geometry and send the information to the connected renderer(s)
    * sliceCtrl->Update();
    * \endcode
    *
    *
    * You can connect visible navigators to a SliceNavigationController, e.g., a
    * QmitkSliderNavigator (for Qt):
    *
    * \code
    * // Create the visible navigator (a slider with a spin-box)
    * QmitkSliderNavigator* navigator =
    *   new QmitkSliderNavigator(parent, "slidernavigator");
    *
    * // Connect the navigator to the slice-stepper of the
    * // SliceNavigationController. For initialization (position, mininal and
    * // maximal values) the values of the SliceNavigationController are used.
    * // Thus, accessing methods of a navigator is normally not necessary, since
    * // everything can be set via the (Qt-independent) SliceNavigationController.
    * // The QmitkStepperAdapter converts the Qt-signals to Qt-independent
    * // itk-events.
    * new QmitkStepperAdapter(navigator, sliceCtrl->GetSlice(), "navigatoradaptor");
    * \endcode
    *
    * If you do not want that all renderwindows are updated when a new slice is
    * selected, you can use a specific RenderingManager, which updates only those
    * renderwindows that should be updated. This is sometimes useful when a 3D view
    * does not need to be updated when the slices in some 2D views are changed.
    * QmitkSliderNavigator (for Qt):
    *
    * \code
    * // create a specific RenderingManager
    * mitk::RenderingManager::Pointer myManager = mitk::RenderingManager::New();
    *
    * // tell the RenderingManager to update only renderwindow1 and renderwindow2
    * myManager->AddRenderWindow(renderwindow1);
    * myManager->AddRenderWindow(renderwindow2);
    *
    * // tell the SliceNavigationController of renderwindow1 and renderwindow2
    * // to use the specific RenderingManager instead of the global one
    * renderwindow1->GetSliceNavigationController()->SetRenderingManager(myManager);
    * renderwindow2->GetSliceNavigationController()->SetRenderingManager(myManager);
    * \endcode
    *
    * \todo implement for non-evenly-timed geometry!
    * \ingroup NavigationControl
    */
   class MITKCORE_EXPORT SliceNavigationController : public BaseController
   {
   public:
     mitkClassMacro(SliceNavigationController, BaseController);
     // itkFactorylessNewMacro(Self)
     // mitkNewMacro1Param(Self, const char *);
     itkNewMacro(Self);
     // itkCloneMacro(Self)
 
     /**
      * \brief Possible view directions, \a Original will uses
      * the PlaneGeometry instances in a SlicedGeometry3D provided
      * as input world geometry (by SetInputWorldGeometry3D).
      */
     enum ViewDirection
     {
       Axial,
       Sagittal,
-      Frontal,
+      Coronal,
       Original
     };
 
     /**
      * \brief Set the input world geometry3D out of which the
      * geometries for slicing will be created.
      *
      * Any previous previous set input geometry (3D or Time) will
      * be ignored in future.
      */
     void SetInputWorldGeometry3D(const mitk::BaseGeometry *geometry);
     itkGetConstObjectMacro(InputWorldGeometry3D, mitk::BaseGeometry);
 
     void SetInputWorldTimeGeometry(const mitk::TimeGeometry *geometry);
     itkGetConstObjectMacro(InputWorldTimeGeometry, mitk::TimeGeometry);
 
     /**
      * \brief Access the created geometry
      */
     itkGetConstObjectMacro(CreatedWorldGeometry, mitk::TimeGeometry);
 
     /**
      * \brief Set the desired view directions
      *
      * \sa ViewDirection
      * \sa Update(ViewDirection viewDirection, bool top = true,
      *     bool frontside = true, bool rotated = false)
      */
     itkSetEnumMacro(ViewDirection, ViewDirection);
     itkGetEnumMacro(ViewDirection, ViewDirection);
 
     /**
      * \brief Set the default view direction
      *
      * This is used to re-initialize the view direction of the SNC to the
      * default value with SetViewDirectionToDefault()
      *
      * \sa ViewDirection
      * \sa Update(ViewDirection viewDirection, bool top = true,
      *     bool frontside = true, bool rotated = false)
      */
     itkSetEnumMacro(DefaultViewDirection, ViewDirection);
     itkGetEnumMacro(DefaultViewDirection, ViewDirection);
 
     const char *GetViewDirectionAsString() const;
 
     virtual void SetViewDirectionToDefault();
 
     /**
      * \brief Do the actual creation and send it to the connected
      * observers (renderers)
      *
      */
     virtual void Update();
 
     /**
      * \brief Extended version of Update, additionally allowing to
      * specify the direction/orientation of the created geometry.
      *
      */
     virtual void Update(ViewDirection viewDirection, bool top = true, bool frontside = true, bool rotated = false);
 
     /**
      * \brief Send the created geometry to the connected
      * observers (renderers)
      *
      * Called by Update().
      */
     virtual void SendCreatedWorldGeometry();
 
     /**
      * \brief Tell observers to re-read the currently selected 2D geometry
      *
      */
     virtual void SendCreatedWorldGeometryUpdate();
 
     /**
      * \brief Send the currently selected slice to the connected
      * observers (renderers)
      *
      * Called by Update().
      */
     virtual void SendSlice();
 
     /**
      * \brief Send the currently selected time to the connected
      * observers (renderers)
      *
      * Called by Update().
      */
     virtual void SendTime();
 
     class MITKCORE_EXPORT TimeGeometryEvent : public itk::AnyEvent
     {
     public:
       typedef TimeGeometryEvent Self;
       typedef itk::AnyEvent Superclass;
 
       TimeGeometryEvent(TimeGeometry *aTimeGeometry, unsigned int aPos) : m_TimeGeometry(aTimeGeometry), m_Pos(aPos) {}
       ~TimeGeometryEvent() override {}
       const char *GetEventName() const override { return "TimeGeometryEvent"; }
       bool CheckEvent(const ::itk::EventObject *e) const override { return dynamic_cast<const Self *>(e); }
       ::itk::EventObject *MakeObject() const override { return new Self(m_TimeGeometry, m_Pos); }
       TimeGeometry *GetTimeGeometry() const { return m_TimeGeometry; }
       unsigned int GetPos() const { return m_Pos; }
     private:
       TimeGeometry::Pointer m_TimeGeometry;
       unsigned int m_Pos;
       // TimeGeometryEvent(const Self&);
       void operator=(const Self &); // just hide
     };
 
 
     mitkTimeGeometryEventMacro(GeometrySendEvent, TimeGeometryEvent);
     mitkTimeGeometryEventMacro(GeometryUpdateEvent, TimeGeometryEvent);
     mitkTimeGeometryEventMacro(GeometryTimeEvent, TimeGeometryEvent);
     mitkTimeGeometryEventMacro(GeometrySliceEvent, TimeGeometryEvent);
 
     template <typename T>
     void ConnectGeometrySendEvent(T *receiver)
     {
       typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
       ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometry);
       unsigned long tag = AddObserver(GeometrySendEvent(nullptr, 0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
     }
 
     template <typename T>
     void ConnectGeometryUpdateEvent(T *receiver)
     {
       typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
       ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::UpdateGeometry);
       unsigned long tag = AddObserver(GeometryUpdateEvent(nullptr, 0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
     }
 
     template <typename T>
     void ConnectGeometrySliceEvent(T *receiver, bool connectSendEvent = true)
     {
       typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
       ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometrySlice);
       unsigned long tag = AddObserver(GeometrySliceEvent(nullptr, 0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
       if (connectSendEvent)
         ConnectGeometrySendEvent(receiver);
     }
 
     template <typename T>
     void ConnectGeometryTimeEvent(T *receiver, bool connectSendEvent = true)
     {
       typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
       ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
       eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometryTime);
       unsigned long tag = AddObserver(GeometryTimeEvent(nullptr, 0), eventReceptorCommand);
       m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
       if (connectSendEvent)
         ConnectGeometrySendEvent(receiver);
     }
 
     template <typename T>
     void ConnectGeometryEvents(T *receiver)
     {
       // connect sendEvent only once
       ConnectGeometrySliceEvent(receiver, false);
       ConnectGeometryTimeEvent(receiver);
     }
 
     // use a templated method to get the right offset when casting to void*
     template <typename T>
     void Disconnect(T *receiver)
     {
       auto i = m_ReceiverToObserverTagsMap.find(static_cast<void *>(receiver));
       if (i == m_ReceiverToObserverTagsMap.end())
         return;
       const std::list<unsigned long> &tags = i->second;
       for (auto tagIter = tags.begin(); tagIter != tags.end(); ++tagIter)
       {
         RemoveObserver(*tagIter);
       }
       m_ReceiverToObserverTagsMap.erase(i);
     }
 
     Message1<mitk::Point3D> SetCrosshairEvent;
 
     /**
      * \brief To connect multiple SliceNavigationController, we can
      * act as an observer ourselves: implemented interface
      * \warning not implemented
      */
     virtual void SetGeometry(const itk::EventObject &geometrySliceEvent);
 
     /**
      * \brief To connect multiple SliceNavigationController, we can
      * act as an observer ourselves: implemented interface
      */
     virtual void SetGeometrySlice(const itk::EventObject &geometrySliceEvent);
 
     /**
      * \brief To connect multiple SliceNavigationController, we can
      * act as an observer ourselves: implemented interface
      */
     virtual void SetGeometryTime(const itk::EventObject &geometryTimeEvent);
 
     /** \brief Positions the SNC according to the specified point */
     void SelectSliceByPoint(const mitk::Point3D &point);
 
     /** \brief Returns the TimeGeometry created by the SNC. */
     mitk::TimeGeometry *GetCreatedWorldGeometry();
 
     /** \brief Returns the BaseGeometry of the currently selected time step. */
     const mitk::BaseGeometry *GetCurrentGeometry3D();
 
     /** \brief Returns the currently selected Plane in the current
      * BaseGeometry (if existent).
      */
     const mitk::PlaneGeometry *GetCurrentPlaneGeometry();
 
     /** \brief Sets the BaseRenderer associated with this SNC (if any). While
      * the BaseRenderer is not directly used by SNC, this is a convenience
      * method to enable BaseRenderer access via the SNC. */
     void SetRenderer(BaseRenderer *renderer);
 
     /** \brief Gets the BaseRenderer associated with this SNC (if any). While
      * the BaseRenderer is not directly used by SNC, this is a convenience
      * method to enable BaseRenderer access via the SNC. Returns nullptr if no
      * BaseRenderer has been specified*/
     BaseRenderer *GetRenderer() const;
 
     /** \brief Re-orients the slice stack. All slices will be oriented to the given normal vector.
          The given point (world coordinates) defines the selected slice.
          Careful: The resulting axis vectors are not clearly defined this way. If you want to define them clearly, use
          ReorientSlices (const mitk::Point3D &point, const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1).
      */
     void ReorientSlices(const mitk::Point3D &point, const mitk::Vector3D &normal);
 
     /** \brief Re-orients the slice stack so that all planes are oriented according to the
     * given axis vectors. The given Point eventually defines selected slice.
     */
     void ReorientSlices(const mitk::Point3D &point, const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1);
 
     void ExecuteOperation(Operation *operation) override;
 
     /**
      * \brief Feature option to lock planes during mouse interaction.
      * This option flag disables the mouse event which causes the center
      * cross to move near by.
      */
     itkSetMacro(SliceLocked, bool);
     itkGetMacro(SliceLocked, bool);
     itkBooleanMacro(SliceLocked);
 
     /**
      * \brief Feature option to lock slice rotation.
      *
      * This option flag disables separately the rotation of a slice which is
      * implemented in mitkSliceRotator.
      */
     itkSetMacro(SliceRotationLocked, bool);
     itkGetMacro(SliceRotationLocked, bool);
     itkBooleanMacro(SliceRotationLocked);
 
     /**
      * \brief Adjusts the numerical range of the slice stepper according to
      * the current geometry orientation of this SNC's SlicedGeometry.
      */
     void AdjustSliceStepperRange();
 
     /** \brief Convenience method that returns the time step currently selected by the controller.*/
     TimeStepType GetSelectedTimeStep() const;
 
     /** \brief Convenience method that returns the time point that corresponds to the selected
      * time step. The conversion is done using the time geometry of the SliceNavigationController.
      * If the time geometry is not yet set, this function will always return 0.0.*/
     TimePointType GetSelectedTimePoint() const;
 
   protected:
     SliceNavigationController();
     ~SliceNavigationController() override;
 
     mitk::BaseGeometry::ConstPointer m_InputWorldGeometry3D;
     mitk::TimeGeometry::ConstPointer m_InputWorldTimeGeometry;
 
     mitk::TimeGeometry::Pointer m_CreatedWorldGeometry;
 
     ViewDirection m_ViewDirection;
     ViewDirection m_DefaultViewDirection;
 
     mitk::RenderingManager::Pointer m_RenderingManager;
 
     mitk::BaseRenderer *m_Renderer;
 
     itkSetMacro(Top, bool);
     itkGetMacro(Top, bool);
     itkBooleanMacro(Top);
 
     itkSetMacro(FrontSide, bool);
     itkGetMacro(FrontSide, bool);
     itkBooleanMacro(FrontSide);
 
     itkSetMacro(Rotated, bool);
     itkGetMacro(Rotated, bool);
     itkBooleanMacro(Rotated);
 
     bool m_Top;
     bool m_FrontSide;
     bool m_Rotated;
 
     bool m_BlockUpdate;
 
     bool m_SliceLocked;
     bool m_SliceRotationLocked;
     unsigned int m_OldPos;
 
     typedef std::map<void *, std::list<unsigned long>> ObserverTagsMapType;
     ObserverTagsMapType m_ReceiverToObserverTagsMap;
   };
 
 } // namespace mitk
 
 #endif /* SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F */
diff --git a/Modules/Core/src/Algorithms/mitkImageTimeSelector.cpp b/Modules/Core/src/Algorithms/mitkImageTimeSelector.cpp
index d7a5360da1..762d545183 100644
--- a/Modules/Core/src/Algorithms/mitkImageTimeSelector.cpp
+++ b/Modules/Core/src/Algorithms/mitkImageTimeSelector.cpp
@@ -1,97 +1,155 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkImageTimeSelector.h"
 
 mitk::ImageTimeSelector::ImageTimeSelector() : m_TimeNr(0), m_ChannelNr(0)
 {
 }
 
 mitk::ImageTimeSelector::~ImageTimeSelector()
 {
 }
 
 void mitk::ImageTimeSelector::GenerateOutputInformation()
 {
   Image::ConstPointer input = this->GetInput();
   Image::Pointer output = this->GetOutput();
 
   itkDebugMacro(<< "GenerateOutputInformation()");
 
   int dim = (input->GetDimension() < 3 ? input->GetDimension() : 3);
   output->Initialize(input->GetPixelType(), dim, input->GetDimensions());
 
   if ((unsigned int)m_TimeNr >= input->GetDimension(3))
   {
     m_TimeNr = input->GetDimension(3) - 1;
   }
 
   // initialize geometry
   mitk::SlicedGeometry3D::Pointer sliced_geo = input->GetSlicedGeometry(m_TimeNr);
   if (sliced_geo.IsNull())
   {
     mitkThrow() << "Failed to retrieve SlicedGeometry from input at timestep " << m_TimeNr;
   }
 
   mitk::SlicedGeometry3D::Pointer sliced_geo_clone = sliced_geo->Clone();
   if (sliced_geo_clone.IsNull())
   {
     mitkThrow() << "Failed to clone the retrieved sliced geometry.";
   }
 
   mitk::BaseGeometry::Pointer geom_3d = dynamic_cast<BaseGeometry *>(sliced_geo_clone.GetPointer());
   if (geom_3d.IsNotNull())
   {
     output->SetGeometry(geom_3d.GetPointer());
   }
   else
   {
     mitkThrow() << "Failed to cast the retrieved SlicedGeometry to a Geometry3D object.";
   }
 
   output->SetPropertyList(input->GetPropertyList()->Clone());
 }
 
 void mitk::ImageTimeSelector::GenerateData()
 {
   const Image::RegionType &requestedRegion = this->GetOutput()->GetRequestedRegion();
 
   // do we really need a complete volume at a time?
   if (requestedRegion.GetSize(2) > 1)
   {
     mitk::ImageDataItem::Pointer im = this->GetVolumeData(m_TimeNr, m_ChannelNr)->Clone();
     im->SetTimestep(0);
     im->SetManageMemory(false);
     this->SetVolumeItem(im, 0);
   }
   else
     // no, so take just a slice!
     this->SetSliceItem(
       this->GetSliceData(requestedRegion.GetIndex(2), m_TimeNr, m_ChannelNr), requestedRegion.GetIndex(2), 0);
 }
 
 void mitk::ImageTimeSelector::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   ImageToImageFilter::InputImagePointer input = this->GetInput();
   Image::Pointer output = this->GetOutput();
 
   Image::RegionType requestedRegion;
   requestedRegion = output->GetRequestedRegion();
   requestedRegion.SetIndex(3, m_TimeNr);
   requestedRegion.SetIndex(4, m_ChannelNr);
   requestedRegion.SetSize(3, 1);
   requestedRegion.SetSize(4, 1);
 
   input->SetRequestedRegion(&requestedRegion);
 }
+
+mitk::Image::ConstPointer mitk::SelectImageByTimeStep(const mitk::Image* image, unsigned int timestep)
+{
+  if (nullptr == image)
+    return image;
+
+  if (image->GetDimension() != 4)
+    return image;
+
+  ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
+
+  imageTimeSelector->SetInput(image);
+  imageTimeSelector->SetTimeNr(static_cast<int>(timestep));
+
+  imageTimeSelector->UpdateLargestPossibleRegion();
+
+  return imageTimeSelector->GetOutput();
+}
+
+mitk::Image::Pointer mitk::SelectImageByTimeStep(mitk::Image* image, unsigned int timestep)
+{
+  if (nullptr == image)
+    return image;
+
+  if (image->GetDimension() != 4)
+    return image;
+
+  ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
+
+  imageTimeSelector->SetInput(image);
+  imageTimeSelector->SetTimeNr(static_cast<int>(timestep));
+
+  imageTimeSelector->UpdateLargestPossibleRegion();
+
+  return imageTimeSelector->GetOutput();
+}
+
+mitk::Image::ConstPointer mitk::SelectImageByTimePoint(const mitk::Image* image, TimePointType timePoint)
+{
+  if (nullptr == image)
+    return image;
+
+  if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
+    return nullptr;
+
+  return SelectImageByTimeStep(image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint));
+}
+
+mitk::Image::Pointer mitk::SelectImageByTimePoint(mitk::Image* image, TimePointType timePoint)
+{
+  if (nullptr == image)
+    return image;
+
+  if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
+    return nullptr;
+
+  return SelectImageByTimeStep(image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint));
+}
diff --git a/Modules/Core/src/Controllers/mitkCameraController.cpp b/Modules/Core/src/Controllers/mitkCameraController.cpp
index f9c46b83b9..001f827ec2 100644
--- a/Modules/Core/src/Controllers/mitkCameraController.cpp
+++ b/Modules/Core/src/Controllers/mitkCameraController.cpp
@@ -1,346 +1,346 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkCameraController.h"
 #include "mitkRenderingManager.h"
 #include "mitkVtkPropRenderer.h"
 #include "vtkCommand.h"
 #include <vtkRenderWindowInteractor.h>
 
 #include "vtkCamera.h"
 #include "vtkRenderer.h"
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
 
 mitk::CameraController::CameraController() : BaseController(), m_Renderer(nullptr)
 {
 }
 
 mitk::CameraController::~CameraController()
 {
 }
 
 mitk::ScalarType mitk::CameraController::ComputeMaxParallelScale()
 {
   double widthInMM = this->GetRenderer()->GetCurrentWorldPlaneGeometry()->GetExtentInMM(0);
   double heightInMM = this->GetRenderer()->GetCurrentWorldPlaneGeometry()->GetExtentInMM(1);
 
   double dispHeight = this->GetRenderer()->GetViewportSize()[1]; // in pixel!
   double dispWidth = this->GetRenderer()->GetViewportSize()[0];
 
   // To get the right zooming factor, we need to set the (half) height to the vtk camera using SetParallelScale.
   // However, it could be, that our picture is so wide or the display so small, that we cannot take the height of the
   // picture.
   // For a wide picture, we have to take the width and adapt the width so that our image fits to the screen.
   // But we can only set the height. Therefore, if the width is the limiting factor, we need to get the ratio of scaling
   // for the width and multiply it with the height, so that we have a modified height and set this one. Believe us, we
   // figured it out...
   if ((dispWidth / widthInMM) < (dispHeight / heightInMM))
   {
     heightInMM = widthInMM / dispWidth * dispHeight;
   }
 
   return heightInMM * 0.5;
 }
 
 void mitk::CameraController::AdjustConstrainedCameraPosition(mitk::Point2D &planePoint)
 {
   // TODO: GetExtentInMM is calculated wrong for rotated planes, e.g. crosshair rotation (bug 19105)
   double widthInMM = this->GetRenderer()->GetCurrentWorldPlaneGeometry()->GetExtentInMM(0);
   double heightInMM = this->GetRenderer()->GetCurrentWorldPlaneGeometry()->GetExtentInMM(1);
 
   mitk::Point2D dispSizeInMM = this->GetRenderer()->GetViewportSizeInMM();
 
   double xMin, xMax, yMin, yMax;
 
   // different calculation of min/max if display is lager/smaller than image.
   // note, that the plane Position defines the middle of the display but is in image coordinates
   //([0,0] is defined by the image, so planePosition can sometimes be negative).
   if (dispSizeInMM[0] > widthInMM)
   {
     xMin = widthInMM - 0.5 * dispSizeInMM[0];
     xMax = 0.5 * dispSizeInMM[0];
   }
   else
   {
     xMin = 0.5 * dispSizeInMM[0];
     xMax = widthInMM - 0.5 * dispSizeInMM[0];
   }
 
   if (dispSizeInMM[1] > heightInMM)
   {
     yMin = heightInMM - 0.5 * dispSizeInMM[1];
     yMax = 0.5 * dispSizeInMM[1];
   }
   else
   {
     yMin = 0.5 * dispSizeInMM[1];
     yMax = heightInMM - 0.5 * dispSizeInMM[1];
   }
 
   if (planePoint[0] < xMin)
   {
     planePoint[0] = xMin;
   }
   if (planePoint[1] < yMin)
   {
     planePoint[1] = yMin;
   }
   if (planePoint[0] > xMax)
   {
     planePoint[0] = xMax;
   }
   if (planePoint[1] > yMax)
   {
     planePoint[1] = yMax;
   }
 }
 
 void mitk::CameraController::SetViewToAnterior()
 {
   this->SetStandardView(ANTERIOR);
 }
 
 void mitk::CameraController::SetViewToPosterior()
 {
   this->SetStandardView(POSTERIOR);
 }
 
 void mitk::CameraController::SetViewToSinister()
 {
   this->SetStandardView(SINISTER);
 }
 
 void mitk::CameraController::SetViewToDexter()
 {
   this->SetStandardView(DEXTER);
 }
 
 void mitk::CameraController::SetViewToCranial()
 {
   this->SetStandardView(CRANIAL);
 }
 
 void mitk::CameraController::SetViewToCaudal()
 {
   this->SetStandardView(CAUDAL);
 }
 
 void mitk::CameraController::SetStandardView(mitk::CameraController::StandardView view)
 {
   const auto *glRenderer = dynamic_cast<const mitk::VtkPropRenderer *>(m_Renderer);
   if (glRenderer == nullptr)
     return;
   vtkRenderer *vtkRenderer = glRenderer->GetVtkRenderer();
   assert(vtkRenderer);
 
   mitk::BoundingBox::Pointer bb;
   mitk::DataStorage *ds = m_Renderer->GetDataStorage();
   if (ds != nullptr)
     bb = ds->ComputeBoundingBox();
   else
     return;
 
   if (m_Renderer->GetMapperID() == mitk::BaseRenderer::Standard3D)
   {
     // set up the view for the 3D render window. The views for 2D are set up in the mitkVtkPropRenderer
     mitk::Point3D middle = bb->GetCenter();
     vtkRenderer->GetActiveCamera()->SetFocalPoint(middle[0], middle[1], middle[2]);
     switch (view)
     {
       case ANTERIOR:
       case POSTERIOR:
       case SINISTER:
       case DEXTER:
         vtkRenderer->GetActiveCamera()->SetViewUp(0, 0, 1);
         break;
       case CRANIAL:
       case CAUDAL:
         vtkRenderer->GetActiveCamera()->SetViewUp(0, -1, 0);
         break;
     }
     switch (view)
     {
       case ANTERIOR:
         vtkRenderer->GetActiveCamera()->SetPosition(middle[0], -100000, middle[2]);
         break;
       case POSTERIOR:
         vtkRenderer->GetActiveCamera()->SetPosition(middle[0], +100000, middle[2]);
         break;
       case SINISTER:
         vtkRenderer->GetActiveCamera()->SetPosition(+100000, middle[1], middle[2]);
         break;
       case DEXTER:
         vtkRenderer->GetActiveCamera()->SetPosition(-100000, middle[1], middle[2]);
         break;
       case CRANIAL:
         vtkRenderer->GetActiveCamera()->SetPosition(middle[0], middle[1], 100000);
         break;
       case CAUDAL:
         vtkRenderer->GetActiveCamera()->SetPosition(middle[0], middle[1], -100000);
         break;
     }
     vtkRenderer->ResetCamera();
 
     vtkRenderer->ResetCameraClippingRange();
   }
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::CameraController::MoveCameraToPoint(const mitk::Point2D &planePoint)
 {
   Point2D moveToPoint = planePoint;
   AdjustCameraToPlane(moveToPoint);
 
   this->Modified();
 }
 
 void mitk::CameraController::MoveBy(const mitk::Vector2D &moveVectorInMM)
 {
   MoveCameraToPoint(GetCameraPositionOnPlane() + moveVectorInMM);
 }
 
 void mitk::CameraController::Zoom(ScalarType factor, const Point2D &zoomPointInMM)
 {
   if (factor <= 0.0)
     return;
   if (this->GetRenderer()->GetMapperID() == BaseRenderer::Standard2D)
   {
     double parallelScale = this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->GetParallelScale() / factor;
     if (this->GetRenderer()->GetConstrainZoomingAndPanning() && factor < 1.0)
     {
       double maxParallelScale = ComputeMaxParallelScale();
       if (maxParallelScale - parallelScale * factor <
           mitk::eps) // this is not the famous 05-bug... Return if already near max zooming
         return;
 
       if (parallelScale > maxParallelScale)
       {
         parallelScale = maxParallelScale;
       }
     }
     this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(parallelScale);
     // Move camera in a way that the clicked point stays visible on the display where it was.
     Point2D planePoint = GetCameraPositionOnPlane();
     MoveCameraToPoint(planePoint + ((zoomPointInMM - planePoint) * (factor - 1)));
   }
 }
 
 mitk::Point2D mitk::CameraController::GetCameraPositionOnPlane()
 {
   Point2D CamPosOnPlane;
   CamPosOnPlane[0] = this->GetRenderer()->GetVtkRenderer()->GetCenter()[0];
   CamPosOnPlane[1] = this->GetRenderer()->GetVtkRenderer()->GetCenter()[1];
   this->GetRenderer()->DisplayToPlane(CamPosOnPlane, CamPosOnPlane);
   return CamPosOnPlane;
 }
 
 void mitk::CameraController::AdjustCameraToPlane()
 {
   if (this->GetRenderer()->GetMapperID() == BaseRenderer::Standard2D)
   {
     AdjustCameraToPlane(GetCameraPositionOnPlane());
   }
 }
 
 void mitk::CameraController::AdjustCameraToPlane(const Point2D &PlanePoint)
 {
   if (this->GetRenderer()->GetMapperID() == BaseRenderer::Standard2D)
   {
     Point2D _planePoint = PlanePoint; // PlanePoint is const...
     if (this->GetRenderer()->GetConstrainZoomingAndPanning())
     {
       double parallelScale = this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->GetParallelScale();
       double maxParallelScale = ComputeMaxParallelScale();
       if (parallelScale > maxParallelScale)
       {
         this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(maxParallelScale);
       }
       AdjustConstrainedCameraPosition(_planePoint);
     }
     const PlaneGeometry *planeGeometry = this->GetRenderer()->GetCurrentWorldPlaneGeometry();
     if (planeGeometry != nullptr)
     {
       this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetViewUp(0, 1, 0); // set the view-up for the camera
       this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetPosition(_planePoint[0], _planePoint[1], 900000);
       this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetFocalPoint(_planePoint[0], _planePoint[1], 0);
-      // Transform the camera to the current position (transversal, coronal and sagittal plane).
+      // Transform the camera to the current position (axial, coronal and sagittal plane).
       // This is necessary, because the SetUserTransform() method does not manipulate the vtkCamera.
       //(Without not all three planes would be visible).
       vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
       vtkSmartPointer<vtkMatrix4x4> matrix = vtkSmartPointer<vtkMatrix4x4>::New();
       Point3D origin;
       Vector3D right, bottom, normal;
 
       origin = planeGeometry->GetOrigin();
       right = planeGeometry->GetAxisVector(0); // right = Extent of Image in mm (worldspace)
       bottom = planeGeometry->GetAxisVector(1);
       normal = planeGeometry->GetNormal();
 
       right.Normalize();
       bottom.Normalize();
       normal.Normalize();
 
       matrix->SetElement(0, 0, right[0]);
       matrix->SetElement(1, 0, right[1]);
       matrix->SetElement(2, 0, right[2]);
       matrix->SetElement(0, 1, bottom[0]);
       matrix->SetElement(1, 1, bottom[1]);
       matrix->SetElement(2, 1, bottom[2]);
       matrix->SetElement(0, 2, normal[0]);
       matrix->SetElement(1, 2, normal[1]);
       matrix->SetElement(2, 2, normal[2]);
       matrix->SetElement(0, 3, origin[0]);
       matrix->SetElement(1, 3, origin[1]);
       matrix->SetElement(2, 3, origin[2]);
       matrix->SetElement(3, 0, 0.0);
       matrix->SetElement(3, 1, 0.0);
       matrix->SetElement(3, 2, 0.0);
       matrix->SetElement(3, 3, 1.0);
 
       trans->SetMatrix(matrix);
-      // Transform the camera to the current position (transversal, coronal and sagittal plane).
+      // Transform the camera to the current position (axial, coronal and sagittal plane).
       this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->ApplyTransform(trans);
     }
   }
 }
 
 void mitk::CameraController::Fit()
 {
   if (this->GetRenderer()->GetMapperID() == BaseRenderer::Standard2D)
   {
     this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(ComputeMaxParallelScale());
 
     this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetClippingRange(0.1, 1000000);
     // Reason for huge range: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823)
     // in VTK bugtracker.
 
     Point2D planePoint;
     planePoint[0] = this->GetRenderer()->GetCurrentWorldPlaneGeometry()->GetExtentInMM(0) * 0.5;
     planePoint[1] = this->GetRenderer()->GetCurrentWorldPlaneGeometry()->GetExtentInMM(1) * 0.5;
     MoveCameraToPoint(planePoint);
   }
 }
 
 void mitk::CameraController::SetScaleFactorInMMPerDisplayUnit(ScalarType scale)
 {
   if (this->GetRenderer()->GetMapperID() != BaseRenderer::Standard2D)
   {
     return;
   }
 
   this->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(this->GetRenderer()->GetViewportSize()[1] *
                                                                              scale * 0.5);
 
   this->Modified();
 }
diff --git a/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp b/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
index b6db4bd18a..65ac9ae5ad 100644
--- a/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
+++ b/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
@@ -1,656 +1,656 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkSliceNavigationController.h"
 #include "mitkAction.h"
 #include "mitkBaseRenderer.h"
 #include "mitkCrosshairPositionEvent.h"
 #include "mitkInteractionConst.h"
 #include "mitkOperation.h"
 #include "mitkOperationActor.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProportionalTimeGeometry.h"
 #include "mitkArbitraryTimeGeometry.h"
 #include "mitkRenderingManager.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkVtkPropRenderer.h"
 
 #include "mitkImage.h"
 #include "mitkImagePixelReadAccessor.h"
 #include "mitkInteractionConst.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkOperationEvent.h"
 #include "mitkPixelTypeMultiplex.h"
 #include "mitkPlaneOperation.h"
 #include "mitkPointOperation.h"
 #include "mitkStatusBar.h"
 #include "mitkUndoController.h"
 
 #include "mitkApplyTransformMatrixOperation.h"
 
 #include "mitkMemoryUtilities.h"
 
 #include <itkCommand.h>
 
 namespace mitk
 {
   SliceNavigationController::SliceNavigationController()
     : BaseController(),
   m_InputWorldGeometry3D( mitk::BaseGeometry::ConstPointer() ),
   m_InputWorldTimeGeometry( mitk::TimeGeometry::ConstPointer() ),
   m_CreatedWorldGeometry( mitk::TimeGeometry::Pointer() ),
       m_ViewDirection(Axial),
       m_DefaultViewDirection(Axial),
   m_RenderingManager( mitk::RenderingManager::Pointer() ),
   m_Renderer( nullptr ),
       m_Top(false),
       m_FrontSide(false),
       m_Rotated(false),
       m_BlockUpdate(false),
       m_SliceLocked(false),
       m_SliceRotationLocked(false),
       m_OldPos(0)
   {
     typedef itk::SimpleMemberCommand<SliceNavigationController> SNCCommandType;
     SNCCommandType::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
 
     sliceStepperChangedCommand = SNCCommandType::New();
     timeStepperChangedCommand = SNCCommandType::New();
 
     sliceStepperChangedCommand->SetCallbackFunction(this, &SliceNavigationController::SendSlice);
 
     timeStepperChangedCommand->SetCallbackFunction(this, &SliceNavigationController::SendTime);
 
     m_Slice->AddObserver(itk::ModifiedEvent(), sliceStepperChangedCommand);
     m_Time->AddObserver(itk::ModifiedEvent(), timeStepperChangedCommand);
 
     m_Slice->SetUnitName("mm");
     m_Time->SetUnitName("ms");
 
     m_Top = false;
     m_FrontSide = false;
     m_Rotated = false;
   }
 
   SliceNavigationController::~SliceNavigationController() {}
   void SliceNavigationController::SetInputWorldGeometry3D(const BaseGeometry *geometry)
   {
   if ( geometry != nullptr )
     {
       if (geometry->GetBoundingBox()->GetDiagonalLength2() < eps)
       {
         itkWarningMacro("setting an empty bounding-box");
       geometry = nullptr;
       }
     }
     if (m_InputWorldGeometry3D != geometry)
     {
       m_InputWorldGeometry3D = geometry;
     m_InputWorldTimeGeometry = mitk::TimeGeometry::ConstPointer();
       this->Modified();
     }
   }
 
   void SliceNavigationController::SetInputWorldTimeGeometry(const TimeGeometry *geometry)
   {
   if ( geometry != nullptr )
     {
       if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() < eps)
       {
         itkWarningMacro("setting an empty bounding-box");
         geometry = nullptr;
       }
     }
     if (m_InputWorldTimeGeometry != geometry)
     {
       m_InputWorldTimeGeometry = geometry;
       m_InputWorldGeometry3D = mitk::BaseGeometry::ConstPointer();
       this->Modified();
     }
   }
 
   void SliceNavigationController::SetViewDirectionToDefault() { m_ViewDirection = m_DefaultViewDirection; }
   const char *SliceNavigationController::GetViewDirectionAsString() const
   {
     const char *viewDirectionString;
     switch (m_ViewDirection)
     {
       case SliceNavigationController::Axial:
         viewDirectionString = "Axial";
         break;
 
       case SliceNavigationController::Sagittal:
         viewDirectionString = "Sagittal";
         break;
 
-      case SliceNavigationController::Frontal:
+      case SliceNavigationController::Coronal:
         viewDirectionString = "Coronal";
         break;
 
       case SliceNavigationController::Original:
         viewDirectionString = "Original";
         break;
 
       default:
         viewDirectionString = "No View Direction Available";
         break;
     }
     return viewDirectionString;
   }
 
   void SliceNavigationController::Update()
   {
     if (!m_BlockUpdate)
     {
       if (m_ViewDirection == Sagittal)
       {
         this->Update(Sagittal, true, true, false);
       }
-      else if (m_ViewDirection == Frontal)
+      else if (m_ViewDirection == Coronal)
       {
-        this->Update(Frontal, false, true, false);
+        this->Update(Coronal, false, true, false);
       }
       else if (m_ViewDirection == Axial)
       {
         this->Update(Axial, false, false, true);
       }
       else
       {
         this->Update(m_ViewDirection);
       }
     }
   }
 
   void SliceNavigationController::Update(SliceNavigationController::ViewDirection viewDirection,
                                          bool top,
                                          bool frontside,
                                          bool rotated)
   {
     TimeGeometry::ConstPointer worldTimeGeometry = m_InputWorldTimeGeometry;
 
     if (m_BlockUpdate || (m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull()) ||
         ((worldTimeGeometry.IsNotNull()) && (worldTimeGeometry->CountTimeSteps() == 0)))
     {
       return;
     }
 
     m_BlockUpdate = true;
 
     if (m_InputWorldTimeGeometry.IsNotNull() && m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime())
     {
       Modified();
     }
     if (m_InputWorldGeometry3D.IsNotNull() && m_LastUpdateTime < m_InputWorldGeometry3D->GetMTime())
     {
       Modified();
     }
     this->SetViewDirection(viewDirection);
     this->SetTop(top);
     this->SetFrontSide(frontside);
     this->SetRotated(rotated);
 
     if (m_LastUpdateTime < GetMTime())
     {
       m_LastUpdateTime = GetMTime();
 
       // initialize the viewplane
       SlicedGeometry3D::Pointer slicedWorldGeometry = SlicedGeometry3D::Pointer();
       BaseGeometry::ConstPointer currentGeometry = BaseGeometry::ConstPointer();
       if (m_InputWorldTimeGeometry.IsNotNull())
         if (m_InputWorldTimeGeometry->IsValidTimeStep(GetTime()->GetPos()))
           currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(GetTime()->GetPos());
         else
           currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(0);
       else
         currentGeometry = m_InputWorldGeometry3D;
 
       m_CreatedWorldGeometry = mitk::TimeGeometry::Pointer();
       switch (viewDirection)
       {
         case Original:
           if (worldTimeGeometry.IsNotNull())
           {
             m_CreatedWorldGeometry = worldTimeGeometry->Clone();
 
             worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
 
             slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(
               m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos()).GetPointer());
 
             if (slicedWorldGeometry.IsNotNull())
             {
               break;
             }
           }
           else
           {
             const auto *worldSlicedGeometry =
               dynamic_cast<const SlicedGeometry3D *>(currentGeometry.GetPointer());
 
           if ( worldSlicedGeometry != nullptr )
             {
               slicedWorldGeometry = static_cast<SlicedGeometry3D *>(currentGeometry->Clone().GetPointer());
               break;
             }
           }
           slicedWorldGeometry = SlicedGeometry3D::New();
           slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::None, top, frontside, rotated);
           slicedWorldGeometry->SetSliceNavigationController(this);
           break;
 
         case Axial:
           slicedWorldGeometry = SlicedGeometry3D::New();
           slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Axial, top, frontside, rotated);
           slicedWorldGeometry->SetSliceNavigationController(this);
           break;
 
-        case Frontal:
+        case Coronal:
           slicedWorldGeometry = SlicedGeometry3D::New();
-          slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Frontal, top, frontside, rotated);
+          slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Coronal, top, frontside, rotated);
           slicedWorldGeometry->SetSliceNavigationController(this);
           break;
 
         case Sagittal:
           slicedWorldGeometry = SlicedGeometry3D::New();
           slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Sagittal, top, frontside, rotated);
           slicedWorldGeometry->SetSliceNavigationController(this);
           break;
         default:
           itkExceptionMacro("unknown ViewDirection");
       }
 
       m_Slice->SetPos(0);
       m_Slice->SetSteps((int)slicedWorldGeometry->GetSlices());
 
       if ( worldTimeGeometry.IsNull() )
       {
         auto createdTimeGeometry = ProportionalTimeGeometry::New();
         createdTimeGeometry->Initialize( slicedWorldGeometry, 1 );
         m_CreatedWorldGeometry = createdTimeGeometry;
 
         m_Time->SetSteps(0);
         m_Time->SetPos(0);
         m_Time->InvalidateRange();
       }
       else
       {
         m_BlockUpdate = true;
         m_Time->SetSteps(worldTimeGeometry->CountTimeSteps());
         m_Time->SetPos(0);
 
         const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
         m_Time->SetRange(timeBounds[0], timeBounds[1]);
 
         m_BlockUpdate = false;
 
         const auto currentTemporalPosition = this->GetTime()->GetPos();
         assert( worldTimeGeometry->GetGeometryForTimeStep( currentTemporalPosition ).IsNotNull() );
 
       if ( dynamic_cast<const mitk::ProportionalTimeGeometry*>( worldTimeGeometry.GetPointer() ) != nullptr )
       {
         const TimePointType minimumTimePoint =
           worldTimeGeometry->TimeStepToTimePoint( currentTemporalPosition );
 
         const TimePointType stepDuration =
           worldTimeGeometry->TimeStepToTimePoint( currentTemporalPosition + 1 ) - minimumTimePoint;
 
         auto createdTimeGeometry = ProportionalTimeGeometry::New();
         createdTimeGeometry->Initialize( slicedWorldGeometry, worldTimeGeometry->CountTimeSteps() );
         createdTimeGeometry->SetFirstTimePoint( minimumTimePoint );
         createdTimeGeometry->SetStepDuration( stepDuration );
 
         m_CreatedWorldGeometry = createdTimeGeometry;
       }
       else
       {
         auto createdTimeGeometry = mitk::ArbitraryTimeGeometry::New();
         const TimeStepType numberOfTimeSteps = worldTimeGeometry->CountTimeSteps();
         createdTimeGeometry->ReserveSpaceForGeometries( numberOfTimeSteps );
 
         for ( TimeStepType i = 0; i < numberOfTimeSteps; ++i )
         {
           const BaseGeometry::Pointer clonedGeometry = slicedWorldGeometry->Clone().GetPointer();
           const auto bounds = worldTimeGeometry->GetTimeBounds( i );
           createdTimeGeometry->AppendNewTimeStep( clonedGeometry,
             bounds[0], bounds[1]);
         }
         createdTimeGeometry->Update();
 
         m_CreatedWorldGeometry = createdTimeGeometry;
       }
       }
     }
 
     // unblock update; we may do this now, because if m_BlockUpdate was already
     // true before this method was entered, then we will never come here.
     m_BlockUpdate = false;
 
     // Send the geometry. Do this even if nothing was changed, because maybe
     // Update() was only called to re-send the old geometry and time/slice data.
     this->SendCreatedWorldGeometry();
     this->SendSlice();
     this->SendTime();
 
     // Adjust the stepper range of slice stepper according to geometry
     this->AdjustSliceStepperRange();
   }
 
   void SliceNavigationController::SendCreatedWorldGeometry()
   {
     // Send the geometry. Do this even if nothing was changed, because maybe
     // Update() was only called to re-send the old geometry.
     if (!m_BlockUpdate)
     {
       this->InvokeEvent(GeometrySendEvent(m_CreatedWorldGeometry, 0));
     }
   }
 
   void SliceNavigationController::SendCreatedWorldGeometryUpdate()
   {
     if (!m_BlockUpdate)
     {
       this->InvokeEvent(GeometryUpdateEvent(m_CreatedWorldGeometry, m_Slice->GetPos()));
     }
   }
 
   void SliceNavigationController::SendSlice()
   {
     if (!m_BlockUpdate)
     {
       if (m_CreatedWorldGeometry.IsNotNull())
       {
         this->InvokeEvent(GeometrySliceEvent(m_CreatedWorldGeometry, m_Slice->GetPos()));
         RenderingManager::GetInstance()->RequestUpdateAll();
       }
     }
   }
 
   void SliceNavigationController::SendTime()
   {
     if (!m_BlockUpdate)
     {
       if (m_CreatedWorldGeometry.IsNotNull())
       {
         this->InvokeEvent(GeometryTimeEvent(m_CreatedWorldGeometry, m_Time->GetPos()));
         RenderingManager::GetInstance()->RequestUpdateAll();
       }
     }
   }
 
   void SliceNavigationController::SetGeometry(const itk::EventObject &) {}
   void SliceNavigationController::SetGeometryTime(const itk::EventObject &geometryTimeEvent)
   {
     if (m_CreatedWorldGeometry.IsNull())
     {
       return;
     }
 
     const auto *timeEvent =
       dynamic_cast< const SliceNavigationController::GeometryTimeEvent * >(&geometryTimeEvent);
     assert( timeEvent != nullptr );
 
     TimeGeometry *timeGeometry = timeEvent->GetTimeGeometry();
     assert( timeGeometry != nullptr );
 
     auto timeStep = (int)timeEvent->GetPos();
     ScalarType timeInMS;
     timeInMS = timeGeometry->TimeStepToTimePoint(timeStep);
     timeStep = m_CreatedWorldGeometry->TimePointToTimeStep(timeInMS);
     this->GetTime()->SetPos(timeStep);
   }
 
   void SliceNavigationController::SetGeometrySlice(const itk::EventObject &geometrySliceEvent)
   {
     const auto *sliceEvent =
       dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(&geometrySliceEvent);
     assert(sliceEvent!=nullptr);
 
     this->GetSlice()->SetPos(sliceEvent->GetPos());
   }
 
   void SliceNavigationController::SelectSliceByPoint(const Point3D &point)
   {
     if (m_CreatedWorldGeometry.IsNull())
     {
       return;
     }
 
     //@todo add time to PositionEvent and use here!!
     SlicedGeometry3D *slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(
       m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos()).GetPointer());
 
     if (slicedWorldGeometry)
     {
       int bestSlice = -1;
       double bestDistance = itk::NumericTraits<double>::max();
 
       int s, slices;
       slices = slicedWorldGeometry->GetSlices();
       if (slicedWorldGeometry->GetEvenlySpaced())
       {
         mitk::PlaneGeometry *plane = slicedWorldGeometry->GetPlaneGeometry(0);
 
         const Vector3D &direction = slicedWorldGeometry->GetDirectionVector();
 
         Point3D projectedPoint;
         plane->Project(point, projectedPoint);
 
         // Check whether the point is somewhere within the slice stack volume;
         // otherwise, the default slice (0) will be selected
         if (direction[0] * (point[0] - projectedPoint[0]) + direction[1] * (point[1] - projectedPoint[1]) +
               direction[2] * (point[2] - projectedPoint[2]) >=
             0)
         {
           bestSlice = (int)(plane->Distance(point) / slicedWorldGeometry->GetSpacing()[2] + 0.5);
         }
       }
       else
       {
         Point3D projectedPoint;
         for (s = 0; s < slices; ++s)
         {
           slicedWorldGeometry->GetPlaneGeometry(s)->Project(point, projectedPoint);
           const Vector3D distance = projectedPoint - point;
           ScalarType currentDistance = distance.GetSquaredNorm();
 
           if (currentDistance < bestDistance)
           {
             bestDistance = currentDistance;
             bestSlice = s;
           }
         }
       }
       if (bestSlice >= 0)
       {
         this->GetSlice()->SetPos(bestSlice);
       }
       else
       {
         this->GetSlice()->SetPos(0);
       }
       this->SendCreatedWorldGeometryUpdate();
       // send crosshair event
       SetCrosshairEvent.Send(point);
     }
   }
 
   void SliceNavigationController::ReorientSlices(const Point3D &point, const Vector3D &normal)
   {
     if (m_CreatedWorldGeometry.IsNull())
     {
       return;
     }
 
     PlaneOperation op(OpORIENT, point, normal);
 
     m_CreatedWorldGeometry->ExecuteOperation(&op);
 
     this->SendCreatedWorldGeometryUpdate();
   }
 
   void SliceNavigationController::ReorientSlices(const mitk::Point3D &point,
                                                  const mitk::Vector3D &axisVec0,
                                                  const mitk::Vector3D &axisVec1)
   {
     if (m_CreatedWorldGeometry)
     {
       PlaneOperation op(OpORIENT, point, axisVec0, axisVec1);
       m_CreatedWorldGeometry->ExecuteOperation(&op);
 
       this->SendCreatedWorldGeometryUpdate();
     }
   }
 
   mitk::TimeGeometry *SliceNavigationController::GetCreatedWorldGeometry() { return m_CreatedWorldGeometry; }
   const mitk::BaseGeometry *SliceNavigationController::GetCurrentGeometry3D()
   {
     if (m_CreatedWorldGeometry.IsNotNull())
     {
       return m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos());
     }
     else
     {
       return nullptr;
     }
   }
 
   const mitk::PlaneGeometry *SliceNavigationController::GetCurrentPlaneGeometry()
   {
     const auto *slicedGeometry =
       dynamic_cast<const mitk::SlicedGeometry3D *>(this->GetCurrentGeometry3D());
 
     if (slicedGeometry)
     {
       const mitk::PlaneGeometry *planeGeometry = (slicedGeometry->GetPlaneGeometry(this->GetSlice()->GetPos()));
       return planeGeometry;
     }
     else
     {
       return nullptr;
     }
   }
 
   void SliceNavigationController::SetRenderer(BaseRenderer *renderer) { m_Renderer = renderer; }
   BaseRenderer *SliceNavigationController::GetRenderer() const { return m_Renderer; }
   void SliceNavigationController::AdjustSliceStepperRange()
   {
     const auto *slicedGeometry =
       dynamic_cast<const mitk::SlicedGeometry3D *>(this->GetCurrentGeometry3D());
 
     const Vector3D &direction = slicedGeometry->GetDirectionVector();
 
     int c = 0;
     int i, k = 0;
     for (i = 0; i < 3; ++i)
     {
       if (fabs(direction[i]) < 0.000000001)
       {
         ++c;
       }
       else
       {
         k = i;
       }
     }
 
     if (c == 2)
     {
       ScalarType min = slicedGeometry->GetOrigin()[k];
       ScalarType max = min + slicedGeometry->GetExtentInMM(k);
 
       m_Slice->SetRange(min, max);
     }
     else
     {
       m_Slice->InvalidateRange();
     }
   }
 
   void SliceNavigationController::ExecuteOperation(Operation *operation)
   {
     // switch on type
     // - select best slice for a given point
     // - rotate created world geometry according to Operation->SomeInfo()
     if (!operation || m_CreatedWorldGeometry.IsNull())
     {
       return;
     }
 
     switch (operation->GetOperationType())
     {
       case OpMOVE: // should be a point operation
       {
         if (!m_SliceLocked) // do not move the cross position
         {
           // select a slice
           auto *po = dynamic_cast<PointOperation *>(operation);
           if (po && po->GetIndex() == -1)
           {
             this->SelectSliceByPoint(po->GetPoint());
           }
           else if (po &&
                    po->GetIndex() != -1) // undo case because index != -1, index holds the old position of this slice
           {
             this->GetSlice()->SetPos(po->GetIndex());
           }
         }
         break;
       }
       case OpRESTOREPLANEPOSITION:
       {
         m_CreatedWorldGeometry->ExecuteOperation(operation);
 
         this->SendCreatedWorldGeometryUpdate();
 
         break;
       }
       case OpAPPLYTRANSFORMMATRIX:
       {
         m_CreatedWorldGeometry->ExecuteOperation(operation);
 
         this->SendCreatedWorldGeometryUpdate();
 
         break;
       }
       default:
       {
         // do nothing
         break;
       }
     }
   }
 
   TimeStepType SliceNavigationController::GetSelectedTimeStep() const
   {
     return this->GetTime()->GetPos();
   }
 
   TimePointType SliceNavigationController::GetSelectedTimePoint() const
   {
     auto timeStep = this->GetSelectedTimeStep();
 
     if (m_CreatedWorldGeometry.IsNull())
     {
       return 0.0;
     }
 
     if (!m_CreatedWorldGeometry->IsValidTimeStep(timeStep))
     {
       mitkThrow() << "SliceNavigationController is in an invalid state. It has a time step"
         << "selected that is not covered by its time geometry. Selected time step: "
         << timeStep << "; TimeGeometry steps count: " << m_CreatedWorldGeometry->CountTimeSteps();
     }
 
     return m_CreatedWorldGeometry->TimeStepToTimePoint(timeStep);
   }
 
 } // namespace
diff --git a/Modules/Core/src/DataManagement/mitkAnatomicalStructureColorPresets.cpp b/Modules/Core/src/DataManagement/mitkAnatomicalStructureColorPresets.cpp
index 6ae41cd508..d5d5735216 100644
--- a/Modules/Core/src/DataManagement/mitkAnatomicalStructureColorPresets.cpp
+++ b/Modules/Core/src/DataManagement/mitkAnatomicalStructureColorPresets.cpp
@@ -1,180 +1,180 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkAnatomicalStructureColorPresets.h"
 #include <vtkObjectFactory.h>
 
 #include "usGetModuleContext.h"
 #include "usModuleContext.h"
 #include "usModule.h"
 #include "usModuleResource.h"
 #include "usModuleResourceStream.h"
 
 namespace mitk {
 
   const std::string AnatomicalStructureColorPresets::PRESET = "preset";
   const std::string AnatomicalStructureColorPresets::CATEGORY = "category";
   const std::string AnatomicalStructureColorPresets::TYPE = "type";
   const std::string AnatomicalStructureColorPresets::MODIFIER = "modifier";
   const std::string AnatomicalStructureColorPresets::COLOR = "color";
 
   const std::string AnatomicalStructureColorPresets::CODE_VALUE = "code_value";
   const std::string AnatomicalStructureColorPresets::CODE_SCHEME = "coding_scheme";
   const std::string AnatomicalStructureColorPresets::CODE_NAME = "code_name";
 
   const std::string AnatomicalStructureColorPresets::COLOR_R = "rgb_r";
   const std::string AnatomicalStructureColorPresets::COLOR_G = "rgb_g";
   const std::string AnatomicalStructureColorPresets::COLOR_B = "rgb_b";
 
 
   vtkStandardNewMacro(AnatomicalStructureColorPresets);
 
   bool AnatomicalStructureColorPresets::LoadPreset()
   {
     us::ModuleResource presetResource = us::GetModuleContext()->GetModule()->GetResource("mitkAnatomicalStructureColorPresets.xml");
     if (!presetResource) return false;
 
     us::ModuleResourceStream presetStream(presetResource);
     vtkXMLParser::SetStream(&presetStream);
     if (!vtkXMLParser::Parse())
     {
 #ifdef INTERDEBUG
       MITK_INFO<<"AnatomicalStructureColorPresets::LoadPreset xml file cannot parse!"<<std::endl;
 #endif
       return false;
     }
     return true;
   }
 
   bool AnatomicalStructureColorPresets::LoadPreset(const std::string& fileName)
   {
     if (fileName.empty())
       return false;
 
     vtkXMLParser::SetFileName(fileName.c_str());
 
     if (!vtkXMLParser::Parse())
     {
 #ifdef INTERDEBUG
       MITK_INFO<<"AnatomicalStructureColorPresets::LoadPreset xml file cannot parse!"<<std::endl;
 #endif
     }
 
     return true;
 
   }
 
   void  AnatomicalStructureColorPresets::StartElement(const char *elementName, const char **atts)
   {
     std::string elementNameString = elementName;
     if (elementNameString == PRESET)
     {
       m_presetName = ReadXMLStringAttribute("name", atts);
     }
     else if (elementNameString == CATEGORY)
     {
       std::string value = ReadXMLStringAttribute(CODE_VALUE, atts);
       std::string scheme = ReadXMLStringAttribute(CODE_SCHEME, atts);
       std::string name = ReadXMLStringAttribute(CODE_NAME, atts);
       m_Category[m_presetName] = Category(value, scheme, name);
     }
     else if (elementNameString == TYPE)
     {
       std::string value = ReadXMLStringAttribute(CODE_VALUE, atts);
       std::string scheme = ReadXMLStringAttribute(CODE_SCHEME, atts);
       std::string name = ReadXMLStringAttribute(CODE_NAME, atts);
       m_Type[m_presetName] = Type(value, scheme, name);
     }
     else if (elementNameString == MODIFIER)
     {
       std::string value = ReadXMLStringAttribute(CODE_VALUE, atts);
       std::string scheme = ReadXMLStringAttribute(CODE_SCHEME, atts);
       std::string name = ReadXMLStringAttribute(CODE_NAME, atts);
       m_Type[m_presetName].modifier = Type::Modifier(value, scheme, name);
     }
     else if (elementNameString == COLOR)
     {
       std::string red = ReadXMLStringAttribute(COLOR_R, atts);
-      float r = atof(red.c_str());
+      float r = atof(red.c_str()) / 255.0f;
       std::string green = ReadXMLStringAttribute(COLOR_G, atts);
-      float g = atof(green.c_str());
+      float g = atof(green.c_str()) / 255.0f;
       std::string blue = ReadXMLStringAttribute(COLOR_B, atts);
-      float b = atof(blue.c_str());
+      float b = atof(blue.c_str()) / 255.0f;
       Color color;
       color.SetRed(r); color.SetGreen(g); color.SetBlue(b);
       m_Color[m_presetName] = color;
     }
   }
 
   std::string AnatomicalStructureColorPresets::ReadXMLStringAttribute(const std::string& name, const char **atts)
   {
     if (atts)
     {
       const char** attsIter = atts;
 
       while (*attsIter != nullptr)
       {
         if (name == *attsIter)
         {
           return *(++attsIter);
         }
         attsIter += 2;
       }
     }
 
     return std::string();
   }
 
   AnatomicalStructureColorPresets::Category AnatomicalStructureColorPresets::GetCategory(const std::string& name)
   {
     return m_Category[name];
   }
 
   AnatomicalStructureColorPresets::Type AnatomicalStructureColorPresets::GetType(const std::string& name)
   {
     return m_Type[name];
   }
 
   Color AnatomicalStructureColorPresets::GetColor(const std::string& name)
   {
     return m_Color[name];
   }
 
   std::map<std::string, AnatomicalStructureColorPresets::Category> const AnatomicalStructureColorPresets::GetCategoryPresets()
   {
     return m_Category;
   }
 
   std::map<std::string, AnatomicalStructureColorPresets::Type> const AnatomicalStructureColorPresets::GetTypePresets()
   {
     return m_Type;
   }
 
   std::map<std::string, Color> const AnatomicalStructureColorPresets::GetColorPresets()
   {
     return m_Color;
   }
 
   void AnatomicalStructureColorPresets::Save()
   {
     //Not yet implemented
   }
 
   void AnatomicalStructureColorPresets::NewPresets(std::map<std::string, AnatomicalStructureColorPresets::Category>& newCategory, std::map<std::string, AnatomicalStructureColorPresets::Type>& newType, std::map<std::string, Color>& newColor)
   {
     m_Category = newCategory;
     m_Type = newType;
     m_Color = newColor;
     this->Save();
   }
 
 }
diff --git a/Modules/Core/src/DataManagement/mitkNodePredicateFirstLevel.cpp b/Modules/Core/src/DataManagement/mitkNodePredicateFirstLevel.cpp
index 6f0fc9037d..996bfac5b5 100644
--- a/Modules/Core/src/DataManagement/mitkNodePredicateFirstLevel.cpp
+++ b/Modules/Core/src/DataManagement/mitkNodePredicateFirstLevel.cpp
@@ -1,33 +1,35 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkNodePredicateFirstLevel.h"
 
 mitk::NodePredicateFirstLevel::NodePredicateFirstLevel(mitk::DataStorage *ds) : NodePredicateBase(), m_DataStorage(ds)
 {
 }
 
 mitk::NodePredicateFirstLevel::~NodePredicateFirstLevel()
 {
 }
 
 bool mitk::NodePredicateFirstLevel::CheckNode(const mitk::DataNode *node) const
 {
   if (node == nullptr)
     throw std::invalid_argument("NodePredicateFirstLevel: invalid node");
 
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
     throw std::invalid_argument("NodePredicateFirstLevel: DataStorage is invalid");
 
-  mitk::DataStorage::SetOfObjects::ConstPointer list = m_DataStorage.Lock()->GetSources(node, nullptr, true);
+  mitk::DataStorage::SetOfObjects::ConstPointer list = dataStorage->GetSources(node, nullptr, true);
   return (list->Size() == 0);
 }
diff --git a/Modules/Core/src/DataManagement/mitkPlaneGeometry.cpp b/Modules/Core/src/DataManagement/mitkPlaneGeometry.cpp
index 013c257025..73ea650550 100644
--- a/Modules/Core/src/DataManagement/mitkPlaneGeometry.cpp
+++ b/Modules/Core/src/DataManagement/mitkPlaneGeometry.cpp
@@ -1,973 +1,972 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkPlaneGeometry.h"
 #include "mitkInteractionConst.h"
 #include "mitkLine.h"
 #include "mitkPlaneOperation.h"
 
 #include <itkSpatialOrientationAdapter.h>
 
 #include <vtkTransform.h>
 
 #include <vnl/vnl_cross.h>
 
 namespace mitk
 {
   PlaneGeometry::PlaneGeometry() : Superclass(), m_ReferenceGeometry(nullptr) { Initialize(); }
   PlaneGeometry::~PlaneGeometry() {}
   PlaneGeometry::PlaneGeometry(const PlaneGeometry &other)
     : Superclass(other), m_ReferenceGeometry(other.m_ReferenceGeometry)
   {
   }
 
   bool PlaneGeometry::CheckRotationMatrix(mitk::AffineTransform3D *transform, double epsilon)
   {
     bool rotation = true;
 
     auto matrix = transform->GetMatrix().GetVnlMatrix();
     matrix.normalize_columns();
 
     auto det = vnl_determinant(matrix);
     if (fabs(det-1.0) > epsilon)
     {
       MITK_WARN << "Invalid rotation matrix! Determinant != 1 (" << det << ")";
       rotation = false;
     }
 
     vnl_matrix_fixed<double, 3, 3> id; id.set_identity();
     auto should_be_id = matrix*matrix.transpose();
     should_be_id -= id;
     auto max = should_be_id.absolute_value_max();
     if (max > epsilon)
     {
       MITK_WARN << "Invalid rotation matrix! R*R^T != ID. Max value: " << max << " (should be 0)";
       rotation = false;
     }
 
     return rotation;
   }
 
   void PlaneGeometry::CheckIndexToWorldTransform(mitk::AffineTransform3D *transform)
   {
     this->CheckRotationMatrix(transform);
   }
 
   void PlaneGeometry::CheckBounds(const BoundingBox::BoundsArrayType &bounds)
   {
     // error: unused parameter 'bounds'
     // this happens in release mode, where the assert macro is defined empty
     // hence we "use" the parameter:
     (void)bounds;
 
     // currently the unit rectangle must be starting at the origin [0,0]
     assert(bounds[0] == 0);
     assert(bounds[2] == 0);
     // the unit rectangle must be two-dimensional
     assert(bounds[1] > 0);
     assert(bounds[3] > 0);
   }
 
   void PlaneGeometry::IndexToWorld(const Point2D &pt_units, Point2D &pt_mm) const
   {
     pt_mm[0] = GetExtentInMM(0) / GetExtent(0) * pt_units[0];
     pt_mm[1] = GetExtentInMM(1) / GetExtent(1) * pt_units[1];
   }
 
   void PlaneGeometry::WorldToIndex(const Point2D &pt_mm, Point2D &pt_units) const
   {
     pt_units[0] = pt_mm[0] * (1.0 / (GetExtentInMM(0) / GetExtent(0)));
     pt_units[1] = pt_mm[1] * (1.0 / (GetExtentInMM(1) / GetExtent(1)));
   }
 
   void PlaneGeometry::IndexToWorld(const Point2D & /*atPt2d_units*/, const Vector2D &vec_units, Vector2D &vec_mm) const
   {
     MITK_WARN << "Warning! Call of the deprecated function PlaneGeometry::IndexToWorld(point, vec, vec). Use "
                  "PlaneGeometry::IndexToWorld(vec, vec) instead!";
     this->IndexToWorld(vec_units, vec_mm);
   }
 
   void PlaneGeometry::IndexToWorld(const Vector2D &vec_units, Vector2D &vec_mm) const
   {
     vec_mm[0] = (GetExtentInMM(0) / GetExtent(0)) * vec_units[0];
     vec_mm[1] = (GetExtentInMM(1) / GetExtent(1)) * vec_units[1];
   }
 
   void PlaneGeometry::WorldToIndex(const Point2D & /*atPt2d_mm*/, const Vector2D &vec_mm, Vector2D &vec_units) const
   {
     MITK_WARN << "Warning! Call of the deprecated function PlaneGeometry::WorldToIndex(point, vec, vec). Use "
                  "PlaneGeometry::WorldToIndex(vec, vec) instead!";
     this->WorldToIndex(vec_mm, vec_units);
   }
 
   void PlaneGeometry::WorldToIndex(const Vector2D &vec_mm, Vector2D &vec_units) const
   {
     vec_units[0] = vec_mm[0] * (1.0 / (GetExtentInMM(0) / GetExtent(0)));
     vec_units[1] = vec_mm[1] * (1.0 / (GetExtentInMM(1) / GetExtent(1)));
   }
 
   void PlaneGeometry::InitializeStandardPlane(mitk::ScalarType width,
                                               ScalarType height,
                                               const Vector3D &spacing,
                                               PlaneGeometry::PlaneOrientation planeorientation,
                                               ScalarType zPosition,
                                               bool frontside,
                                               bool rotated,
                                               bool top)
   {
     AffineTransform3D::Pointer transform;
 
     transform = AffineTransform3D::New();
     AffineTransform3D::MatrixType matrix;
     AffineTransform3D::MatrixType::InternalMatrixType &vnlmatrix = matrix.GetVnlMatrix();
 
     vnlmatrix.set_identity();
     vnlmatrix(0, 0) = spacing[0];
     vnlmatrix(1, 1) = spacing[1];
     vnlmatrix(2, 2) = spacing[2];
     transform->SetIdentity();
     transform->SetMatrix(matrix);
 
     InitializeStandardPlane(width, height, transform.GetPointer(), planeorientation, zPosition, frontside, rotated, top);
   }
 
   void PlaneGeometry::InitializeStandardPlane(mitk::ScalarType width,
                                               mitk::ScalarType height,
                                               const AffineTransform3D *transform /* = nullptr */,
                                               PlaneGeometry::PlaneOrientation planeorientation /* = Axial */,
                                               mitk::ScalarType zPosition /* = 0 */,
                                               bool frontside /* = true */,
                                               bool rotated /* = false */,
                                               bool top /* = true */)
   {
     Superclass::Initialize();
 
     /// construct standard view.
 
     // We define at the moment "frontside" as: axial from above,
-    // coronal from front (nose), saggital from right.
+    // coronal from front (nose), sagittal from right.
     // TODO: Double check with medicals doctors or radiologists [ ].
 
     // We define the orientation in patient's view, e.g. LAI is in a axial cut
     // (parallel to the triangle ear-ear-nose):
     // first axis: To the left ear of the patient
     // seecond axis: To the nose of the patient
     // third axis: To the legs of the patient.
 
     // Options are: L/R left/right; A/P anterior/posterior; I/S inferior/superior
     // (AKA caudal/cranial).
     // We note on all cases in the following switch block r.h. for right handed
     // or l.h. for left handed to describe the different cases.
     // However, which system is chosen is defined at the end of the switch block.
 
     // CAVE / be careful: the vectors right and bottom are relative to the plane
     // and do NOT describe e.g. the right side of the patient.
 
     Point3D origin;
     /** Bottom means downwards, DV means Direction Vector. Both relative to the image! */
     VnlVector rightDV(3), bottomDV(3);
     /** Origin of this plane is by default a zero vector and implicitly in the top-left corner: */
     origin.Fill(0);
     /** This is different to all definitions in MITK, except the QT mouse clicks.
     *   But it is like this here and we don't want to change a running system.
     *   Just be aware, that IN THIS FUNCTION we define the origin at the top left (e.g. your screen). */
 
     /** NormalDirection defines which axis (i.e. column index in the transform matrix)
     * is perpendicular to the plane: */
     int normalDirection;
 
     switch (planeorientation) // Switch through our limited choice of standard planes:
     {
       case None:
       /** Orientation 'None' shall be done like the axial plane orientation,
        *  for whatever reasons. */
       case Axial:
         if (frontside) // Radiologist's view from below. A cut along the triangle ear-ear-nose.
         {
           if (rotated == false)
           /** Origin in the top-left corner, x=[1; 0; 0], y=[0; 1; 0], z=[0; 0; 1],
           *   origin=[0,0,zpos]: LAI (r.h.)
           *
           *  0---rightDV---->                            |
           *  |                                           |
           *  |  Picture of a finite, rectangular plane   |
           *  |  ( insert LOLCAT-scan here ^_^ )          |
           *  |                                           |
           *  v  _________________________________________|
           *
           */
           {
             FillVector3D(origin, 0, 0, zPosition);
             FillVector3D(rightDV, 1, 0, 0);
             FillVector3D(bottomDV, 0, 1, 0);
           }
           else // Origin rotated to the bottom-right corner, x=[-1; 0; 0], y=[0; -1; 0], z=[0; 0; 1],
                // origin=[w,h,zpos]: RPI (r.h.)
           {    // Caveat emptor:  Still  using  top-left  as  origin  of  index  coordinate  system!
             FillVector3D(origin, width, height, zPosition);
             FillVector3D(rightDV, -1, 0, 0);
             FillVector3D(bottomDV, 0, -1, 0);
           }
         }
         else // 'Backside, not frontside.' Neuro-Surgeons's view from above patient.
         {
           if (rotated == false) // x=[-1; 0; 0], y=[0; 1; 0], z=[0; 0; 1], origin=[w,0,zpos]:  RAS (r.h.)
           {
             FillVector3D(origin, width, 0, zPosition);
             FillVector3D(rightDV, -1, 0, 0);
             FillVector3D(bottomDV, 0, 1, 0);
           }
           else // Origin in the bottom-left corner, x=[1; 0; 0], y=[0; -1; 0], z=[0; 0; 1],
                // origin=[0,h,zpos]:  LPS (r.h.)
           {
             FillVector3D(origin, 0, height, zPosition);
             FillVector3D(rightDV, 1, 0, 0);
             FillVector3D(bottomDV, 0, -1, 0);
           }
         }
         normalDirection = 2; // That is S=Superior=z=third_axis=middlefinger in righthanded LPS-system.
         break;
 
-      // Frontal is known as Coronal in mitk. Plane cuts through patient's ear-ear-heel-heel:
-      case Frontal:
+      case Coronal: // Coronal=Frontal plane; cuts through patient's ear-ear-heel-heel:
         if (frontside)
         {
           if (rotated == false) // x=[1; 0; 0], y=[0; 0; 1], z=[0; 1; 0], origin=[0,zpos,0]: LAI (r.h.)
           {
             FillVector3D(origin, 0, zPosition, 0);
             FillVector3D(rightDV, 1, 0, 0);
             FillVector3D(bottomDV, 0, 0, 1);
           }
           else // x=[-1;0;0], y=[0;0;-1], z=[0;1;0], origin=[w,zpos,h]:  RAS  (r.h.)
           {
             FillVector3D(origin, width, zPosition, height);
             FillVector3D(rightDV, -1, 0, 0);
             FillVector3D(bottomDV, 0, 0, -1);
           }
         }
         else
         {
           if (rotated == false) //  x=[-1;0;0], y=[0;0;1], z=[0;1;0], origin=[w,zpos,0]: RPI (r.h.)
           {
             FillVector3D(origin, width, zPosition, 0);
             FillVector3D(rightDV, -1, 0, 0);
             FillVector3D(bottomDV, 0, 0, 1);
           }
           else //  x=[1;0;0], y=[0;1;0], z=[0;0;-1], origin=[0,zpos,h]: LPS (r.h.)
           {
             FillVector3D(origin, 0, zPosition, height);
             FillVector3D(rightDV, 1, 0, 0);
             FillVector3D(bottomDV, 0, 0, -1);
           }
         }
         normalDirection = 1; // Normal vector = posterior direction.
         break;
 
       case Sagittal: // Sagittal=Medial plane, the symmetry-plane mirroring your face.
         if (frontside)
         {
           if (rotated == false) //  x=[0;1;0], y=[0;0;1], z=[1;0;0], origin=[zpos,0,0]:  LAI (r.h.)
           {
             FillVector3D(origin, zPosition, 0, 0);
             FillVector3D(rightDV, 0, 1, 0);
             FillVector3D(bottomDV, 0, 0, 1);
           }
           else //  x=[0;-1;0], y=[0;0;-1], z=[1;0;0], origin=[zpos,w,h]:  LPS (r.h.)
           {
             FillVector3D(origin, zPosition, width, height);
             FillVector3D(rightDV, 0, -1, 0);
             FillVector3D(bottomDV, 0, 0, -1);
           }
         }
         else
         {
           if (rotated == false) //  x=[0;-1;0], y=[0;0;1], z=[1;0;0], origin=[zpos,w,0]:  RPI (r.h.)
           {
             FillVector3D(origin, zPosition, width, 0);
             FillVector3D(rightDV, 0, -1, 0);
             FillVector3D(bottomDV, 0, 0, 1);
           }
           else //  x=[0;1;0], y=[0;0;-1], z=[1;0;0], origin=[zpos,0,h]:  RAS (r.h.)
           {
             FillVector3D(origin, zPosition, 0, height);
             FillVector3D(rightDV, 0, 1, 0);
             FillVector3D(bottomDV, 0, 0, -1);
           }
         }
         normalDirection = 0; // Normal vector = Lateral direction: Left in a LPS-system.
         break;
 
       default:
         itkExceptionMacro("unknown PlaneOrientation");
     }
 
     VnlVector normal(3);
     FillVector3D(normal, 0, 0, 0);
     normal[normalDirection] = top ? 1 : -1;
 
     if ( transform != nullptr )
     {
       origin = transform->TransformPoint( origin );
       rightDV = transform->TransformVector( rightDV ).as_ref();
       bottomDV = transform->TransformVector( bottomDV ).as_ref();
       normal = transform->TransformVector( normal ).as_ref();
     }
 
     ScalarType bounds[6] = {0, width, 0, height, 0, 1};
     this->SetBounds(bounds);
 
     AffineTransform3D::Pointer planeTransform = AffineTransform3D::New();
     Matrix3D matrix;
     matrix.GetVnlMatrix().set_column(0, rightDV.as_ref());
     matrix.GetVnlMatrix().set_column(1, bottomDV.as_ref());
     matrix.GetVnlMatrix().set_column(2, normal.as_ref());
     planeTransform->SetMatrix(matrix);
     planeTransform->SetOffset(this->GetIndexToWorldTransform()->GetOffset());
     this->SetIndexToWorldTransform(planeTransform);
 
     this->SetOrigin(origin);
   }
 
   std::vector< int > PlaneGeometry::CalculateDominantAxes(mitk::AffineTransform3D::MatrixType::InternalMatrixType& rotation_matrix)
   {
     std::vector< int > axes;
 
     bool dominant_axis_error = false;
     for (int i = 0; i < 3; ++i)
     {
       int dominantAxis = itk::Function::Max3(
           rotation_matrix[0][i],
           rotation_matrix[1][i],
           rotation_matrix[2][i]
       );
 
       for (int j=0; j<i; ++j)
         if (axes[j] == dominantAxis)
         {
           dominant_axis_error = true;
           break;
         }
       if (dominant_axis_error)
         break;
 
       axes.push_back(dominantAxis);
     }
 
     if (dominant_axis_error)
     {
       MITK_DEBUG << "Error during dominant axis calculation. Using default.";
       MITK_DEBUG << "This is either caused by an imperfect rotation matrix or if the rotation is axactly 45° around one or more axis.";
       axes.clear();
       for (int i = 0; i < 3; ++i)
         axes.push_back(i);
     }
 
     return axes;
   }
 
   void PlaneGeometry::InitializeStandardPlane(const BaseGeometry *geometry3D,
                                               PlaneOrientation planeorientation,
                                               ScalarType zPosition,
                                               bool frontside,
                                               bool rotated,
                                               bool top)
   {
     this->SetReferenceGeometry(geometry3D);
 
     ScalarType width, height;
 
     // Inspired by:
     // http://www.na-mic.org/Wiki/index.php/Coordinate_System_Conversion_Between_ITK_and_Slicer3
 
     mitk::AffineTransform3D::MatrixType matrix = geometry3D->GetIndexToWorldTransform()->GetMatrix();
 
     matrix.GetVnlMatrix().normalize_columns();
     mitk::AffineTransform3D::MatrixType::InternalMatrixType inverseMatrix = matrix.GetTranspose();
 
     /// The index of the sagittal, coronal and axial axes in the reference geometry.
     auto axes = CalculateDominantAxes(inverseMatrix);
     /// The direction of the sagittal, coronal and axial axes in the reference geometry.
     /// +1 means that the direction is straight, i.e. greater index translates to greater
     /// world coordinate. -1 means that the direction is inverted.
     int directions[3];
     ScalarType extents[3];
     ScalarType spacings[3];
     for (int i=0; i<3; ++i)
     {
       int dominantAxis = axes.at(i);
       directions[i] = itk::Function::Sign(inverseMatrix[dominantAxis][i]);
       extents[i] = geometry3D->GetExtent(dominantAxis);
       spacings[i] = geometry3D->GetSpacing()[dominantAxis];
     }
 
     // matrix(column) = inverseTransformMatrix(row) * flippedAxes * spacing
     matrix[0][0] = inverseMatrix[axes[0]][0] * directions[0] * spacings[0];
     matrix[1][0] = inverseMatrix[axes[0]][1] * directions[0] * spacings[0];
     matrix[2][0] = inverseMatrix[axes[0]][2] * directions[0] * spacings[0];
     matrix[0][1] = inverseMatrix[axes[1]][0] * directions[1] * spacings[1];
     matrix[1][1] = inverseMatrix[axes[1]][1] * directions[1] * spacings[1];
     matrix[2][1] = inverseMatrix[axes[1]][2] * directions[1] * spacings[1];
     matrix[0][2] = inverseMatrix[axes[2]][0] * directions[2] * spacings[2];
     matrix[1][2] = inverseMatrix[axes[2]][1] * directions[2] * spacings[2];
     matrix[2][2] = inverseMatrix[axes[2]][2] * directions[2] * spacings[2];
 
     /// The "world origin" is the corner with the lowest physical coordinates.
     /// We use it as a reference point so that we get the correct anatomical
     /// orientations.
     Point3D worldOrigin = geometry3D->GetOrigin();
     for (int i = 0; i < 3; ++i)
     {
       /// The distance of the plane origin from the world origin in voxels.
       double offset = directions[i] > 0 ? 0.0 : extents[i];
 
       if (geometry3D->GetImageGeometry())
       {
         offset += directions[i] * 0.5;
       }
 
       for (int j = 0; j < 3; ++j)
       {
         worldOrigin[j] -= offset * matrix[j][i];
       }
     }
 
     switch(planeorientation)
     {
     case None:
     /** Orientation 'None' shall be done like the axial plane orientation,
      *  for whatever reasons. */
     case Axial:
       width  = extents[0];
       height = extents[1];
       break;
-    case Frontal:
+    case Coronal:
       width  = extents[0];
       height = extents[2];
       break;
     case Sagittal:
       width  = extents[1];
       height = extents[2];
       break;
     default:
       itkExceptionMacro("unknown PlaneOrientation");
     }
 
     ScalarType bounds[6]= { 0, width, 0, height, 0, 1 };
     this->SetBounds( bounds );
 
     AffineTransform3D::Pointer transform = AffineTransform3D::New();
     transform->SetMatrix(matrix);
     transform->SetOffset(worldOrigin.GetVectorFromOrigin());
 
     InitializeStandardPlane(
       width, height, transform, planeorientation, zPosition, frontside, rotated, top);
   }
 
   void PlaneGeometry::InitializeStandardPlane(
     const BaseGeometry *geometry3D, bool top, PlaneOrientation planeorientation, bool frontside, bool rotated)
   {
     /// The index of the sagittal, coronal and axial axes in world coordinate system.
     int worldAxis;
     switch(planeorientation)
     {
     case None:
     /** Orientation 'None' shall be done like the axial plane orientation,
      *  for whatever reasons. */
     case Axial:
       worldAxis = 2;
       break;
-    case Frontal:
+    case Coronal:
       worldAxis = 1;
       break;
     case Sagittal:
       worldAxis = 0;
       break;
     default:
       itkExceptionMacro("unknown PlaneOrientation");
     }
 
     // Inspired by:
     // http://www.na-mic.org/Wiki/index.php/Coordinate_System_Conversion_Between_ITK_and_Slicer3
 
     mitk::AffineTransform3D::ConstPointer affineTransform = geometry3D->GetIndexToWorldTransform();
     mitk::AffineTransform3D::MatrixType matrix = affineTransform->GetMatrix();
     matrix.GetVnlMatrix().normalize_columns();
     mitk::AffineTransform3D::MatrixType::InternalMatrixType inverseMatrix = matrix.GetInverse();
 
     /// The index of the sagittal, coronal and axial axes in the reference geometry.
     int dominantAxis = CalculateDominantAxes(inverseMatrix).at(worldAxis);
 
     ScalarType zPosition = top ? 0.5 : geometry3D->GetExtent(dominantAxis) - 0.5;
 
     InitializeStandardPlane(geometry3D, planeorientation, zPosition, frontside, rotated, top);
   }
 
   void PlaneGeometry::InitializeStandardPlane(const Vector3D &rightVector,
                                               const Vector3D &downVector,
                                               const Vector3D *spacing)
   {
     InitializeStandardPlane(rightVector.GetVnlVector(), downVector.GetVnlVector(), spacing);
   }
 
   void PlaneGeometry::InitializeStandardPlane(const VnlVector &rightVector,
                                               const VnlVector &downVector,
                                               const Vector3D *spacing)
   {
     ScalarType width = rightVector.two_norm();
     ScalarType height = downVector.two_norm();
 
     InitializeStandardPlane(width, height, rightVector, downVector, spacing);
   }
 
   void PlaneGeometry::InitializeStandardPlane(mitk::ScalarType width,
                                               ScalarType height,
                                               const Vector3D &rightVector,
                                               const Vector3D &downVector,
                                               const Vector3D *spacing)
   {
     InitializeStandardPlane(width, height, rightVector.GetVnlVector(), downVector.GetVnlVector(), spacing);
   }
 
   void PlaneGeometry::InitializeStandardPlane(mitk::ScalarType width,
                                               ScalarType height,
                                               const VnlVector &rightVector,
                                               const VnlVector &downVector,
                                               const Vector3D *spacing)
   {
     assert(width > 0);
     assert(height > 0);
 
     VnlVector rightDV = rightVector;
     rightDV.normalize();
     VnlVector downDV = downVector;
     downDV.normalize();
     VnlVector normal = vnl_cross_3d(rightVector, downVector);
     normal.normalize();
     // Crossproduct vnl_cross_3d is always righthanded, but that is okay here
     // because in this method we create a new IndexToWorldTransform and
     // spacing with 1 or 3 negative components could still make it lefthanded.
 
     if (spacing != nullptr)
     {
       rightDV *= (*spacing)[0];
       downDV *= (*spacing)[1];
       normal *= (*spacing)[2];
     }
 
     AffineTransform3D::Pointer transform = AffineTransform3D::New();
     Matrix3D matrix;
     matrix.GetVnlMatrix().set_column(0, rightDV);
     matrix.GetVnlMatrix().set_column(1, downDV);
     matrix.GetVnlMatrix().set_column(2, normal);
     transform->SetMatrix(matrix);
     transform->SetOffset(this->GetIndexToWorldTransform()->GetOffset());
 
     ScalarType bounds[6] = {0, width, 0, height, 0, 1};
     this->SetBounds(bounds);
 
     this->SetIndexToWorldTransform(transform);
   }
 
   void PlaneGeometry::InitializePlane(const Point3D &origin, const Vector3D &normal)
   {
     VnlVector rightVectorVnl(3), downVectorVnl;
 
     if (Equal(normal[1], 0.0f) == false)
     {
       FillVector3D(rightVectorVnl, 1.0f, -normal[0] / normal[1], 0.0f);
       rightVectorVnl.normalize();
     }
     else
     {
       FillVector3D(rightVectorVnl, 0.0f, 1.0f, 0.0f);
     }
     downVectorVnl = vnl_cross_3d(normal.GetVnlVector(), rightVectorVnl);
     downVectorVnl.normalize();
     // Crossproduct vnl_cross_3d is always righthanded.
 
     InitializeStandardPlane(rightVectorVnl, downVectorVnl);
 
     SetOrigin(origin);
   }
 
   void PlaneGeometry::SetMatrixByVectors(const VnlVector &rightVector,
                                          const VnlVector &downVector,
                                          ScalarType thickness /* = 1.0 */)
   {
     VnlVector normal = vnl_cross_3d(rightVector, downVector);
     normal.normalize();
     normal *= thickness;
     // Crossproduct vnl_cross_3d is always righthanded, but that is okay here
     // because in this method we create a new IndexToWorldTransform and
     // a negative thickness could still make it lefthanded.
 
     AffineTransform3D::Pointer transform = AffineTransform3D::New();
     Matrix3D matrix;
     matrix.GetVnlMatrix().set_column(0, rightVector);
     matrix.GetVnlMatrix().set_column(1, downVector);
     matrix.GetVnlMatrix().set_column(2, normal);
     transform->SetMatrix(matrix);
     transform->SetOffset(this->GetIndexToWorldTransform()->GetOffset());
     SetIndexToWorldTransform(transform);
   }
 
   Vector3D PlaneGeometry::GetNormal() const
   {
     Vector3D frontToBack;
     frontToBack.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).as_ref());
 
     return frontToBack;
   }
 
   VnlVector PlaneGeometry::GetNormalVnl() const
   {
     return this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).as_ref();
   }
 
   ScalarType PlaneGeometry::DistanceFromPlane(const Point3D &pt3d_mm) const { return fabs(SignedDistance(pt3d_mm)); }
   ScalarType PlaneGeometry::SignedDistance(const Point3D &pt3d_mm) const { return SignedDistanceFromPlane(pt3d_mm); }
   bool PlaneGeometry::IsAbove(const Point3D &pt3d_mm, bool considerBoundingBox) const
   {
     if (considerBoundingBox)
     {
       Point3D pt3d_units;
       BaseGeometry::WorldToIndex(pt3d_mm, pt3d_units);
       return (pt3d_units[2] > this->GetBoundingBox()->GetBounds()[4]);
     }
     else
       return SignedDistanceFromPlane(pt3d_mm) > 0;
   }
 
   bool PlaneGeometry::IntersectionLine(const PlaneGeometry* plane, Line3D& crossline) const
   {
     Vector3D normal = this->GetNormal();
     normal.Normalize();
 
     Vector3D planeNormal = plane->GetNormal();
     planeNormal.Normalize();
 
     Vector3D direction = itk::CrossProduct(normal, planeNormal);
 
     if (direction.GetSquaredNorm() < eps)
       return false;
 
     crossline.SetDirection(direction);
 
     double N1dN2 = normal * planeNormal;
     double determinant = 1.0 - N1dN2 * N1dN2;
 
     Vector3D origin = this->GetOrigin().GetVectorFromOrigin();
     Vector3D planeOrigin = plane->GetOrigin().GetVectorFromOrigin();
 
     double d1 = normal * origin;
     double d2 = planeNormal * planeOrigin;
 
     double c1 = (d1 - d2 * N1dN2) / determinant;
     double c2 = (d2 - d1 * N1dN2) / determinant;
 
     Vector3D p = normal * c1 + planeNormal * c2;
     crossline.GetPoint()[0] = p.GetVnlVector()[0];
     crossline.GetPoint()[1] = p.GetVnlVector()[1];
     crossline.GetPoint()[2] = p.GetVnlVector()[2];
 
     return true;
   }
 
   unsigned int PlaneGeometry::IntersectWithPlane2D(const PlaneGeometry *plane, Point2D &lineFrom, Point2D &lineTo) const
   {
     Line3D crossline;
     if (this->IntersectionLine(plane, crossline) == false)
       return 0;
 
     Point2D point2;
     Vector2D direction2;
 
     this->Map(crossline.GetPoint(), point2);
     this->Map(crossline.GetPoint(), crossline.GetDirection(), direction2);
 
     return Line3D::RectangleLineIntersection(
       0, 0, GetExtentInMM(0), GetExtentInMM(1), point2, direction2, lineFrom, lineTo);
   }
 
   double PlaneGeometry::Angle(const PlaneGeometry *plane) const
   {
     return angle(plane->GetMatrixColumn(2), GetMatrixColumn(2));
   }
 
   double PlaneGeometry::Angle(const Line3D &line) const
   {
     return vnl_math::pi_over_2 - angle(line.GetDirection().GetVnlVector(), GetMatrixColumn(2));
   }
 
   bool PlaneGeometry::IntersectionPoint(const Line3D &line, Point3D &intersectionPoint) const
   {
     Vector3D planeNormal = this->GetNormal();
     planeNormal.Normalize();
 
     Vector3D lineDirection = line.GetDirection();
     lineDirection.Normalize();
 
     double t = planeNormal * lineDirection;
     if (fabs(t) < eps)
     {
       return false;
     }
 
     Vector3D diff;
     diff = this->GetOrigin() - line.GetPoint();
     t = (planeNormal * diff) / t;
 
     intersectionPoint = line.GetPoint() + lineDirection * t;
     return true;
   }
 
   bool PlaneGeometry::IntersectionPointParam(const Line3D &line, double &t) const
   {
     Vector3D planeNormal = this->GetNormal();
 
     Vector3D lineDirection = line.GetDirection();
 
     t = planeNormal * lineDirection;
 
     if (fabs(t) < eps)
     {
       return false;
     }
 
     Vector3D diff;
     diff = this->GetOrigin() - line.GetPoint();
     t = (planeNormal * diff) / t;
     return true;
   }
 
   bool PlaneGeometry::IsParallel(const PlaneGeometry *plane) const
   {
     return ((Angle(plane) < 10.0 * mitk::sqrteps) || (Angle(plane) > (vnl_math::pi - 10.0 * sqrteps)));
   }
 
   bool PlaneGeometry::IsOnPlane(const Point3D &point) const { return Distance(point) < eps; }
   bool PlaneGeometry::IsOnPlane(const Line3D &line) const
   {
     return ((Distance(line.GetPoint()) < eps) && (Distance(line.GetPoint2()) < eps));
   }
 
   bool PlaneGeometry::IsOnPlane(const PlaneGeometry *plane) const
   {
     return (IsParallel(plane) && (Distance(plane->GetOrigin()) < eps));
   }
 
   Point3D PlaneGeometry::ProjectPointOntoPlane(const Point3D &pt) const
   {
     ScalarType len = this->GetNormalVnl().two_norm();
     return pt - this->GetNormal() * this->SignedDistanceFromPlane(pt) / len;
   }
 
   itk::LightObject::Pointer PlaneGeometry::InternalClone() const
   {
     Self::Pointer newGeometry = new PlaneGeometry(*this);
     newGeometry->UnRegister();
     return newGeometry.GetPointer();
   }
 
   void PlaneGeometry::ExecuteOperation(Operation *operation)
   {
     vtkTransform *transform = vtkTransform::New();
     transform->SetMatrix(this->GetVtkMatrix());
 
     switch (operation->GetOperationType())
     {
       case OpORIENT:
       {
         auto *planeOp = dynamic_cast<mitk::PlaneOperation *>(operation);
         if (planeOp == nullptr)
         {
           return;
         }
 
         Point3D center = planeOp->GetPoint();
 
         Vector3D orientationVector = planeOp->GetNormal();
         Vector3D defaultVector;
         FillVector3D(defaultVector, 0.0, 0.0, 1.0);
 
         Vector3D rotationAxis = itk::CrossProduct(orientationVector, defaultVector);
         // double rotationAngle = acos( orientationVector[2] / orientationVector.GetNorm() );
 
         double rotationAngle = atan2((double)rotationAxis.GetNorm(), (double)(orientationVector * defaultVector));
         rotationAngle *= 180.0 / vnl_math::pi;
 
         transform->PostMultiply();
         transform->Identity();
         transform->Translate(center[0], center[1], center[2]);
         transform->RotateWXYZ(rotationAngle, rotationAxis[0], rotationAxis[1], rotationAxis[2]);
         transform->Translate(-center[0], -center[1], -center[2]);
         break;
       }
       case OpRESTOREPLANEPOSITION:
       {
         auto *op = dynamic_cast<mitk::RestorePlanePositionOperation *>(operation);
         if (op == nullptr)
         {
           return;
         }
 
         AffineTransform3D::Pointer transform2 = AffineTransform3D::New();
         Matrix3D matrix;
         matrix.GetVnlMatrix().set_column(0, op->GetTransform()->GetMatrix().GetVnlMatrix().get_column(0));
         matrix.GetVnlMatrix().set_column(1, op->GetTransform()->GetMatrix().GetVnlMatrix().get_column(1));
         matrix.GetVnlMatrix().set_column(2, op->GetTransform()->GetMatrix().GetVnlMatrix().get_column(2));
         transform2->SetMatrix(matrix);
         Vector3D offset = op->GetTransform()->GetOffset();
         transform2->SetOffset(offset);
 
         this->SetIndexToWorldTransform(transform2);
         ScalarType bounds[6] = {0, op->GetWidth(), 0, op->GetHeight(), 0, 1};
         this->SetBounds(bounds);
         this->Modified();
         transform->Delete();
         return;
       }
       default:
         Superclass::ExecuteOperation(operation);
         transform->Delete();
         return;
     }
 
     this->SetVtkMatrixDeepCopy(transform);
     this->Modified();
     transform->Delete();
   }
 
   void PlaneGeometry::PrintSelf(std::ostream &os, itk::Indent indent) const
   {
     Superclass::PrintSelf(os, indent);
     os << indent << " ScaleFactorMMPerUnitX: " << GetExtentInMM(0) / GetExtent(0) << std::endl;
     os << indent << " ScaleFactorMMPerUnitY: " << GetExtentInMM(1) / GetExtent(1) << std::endl;
     os << indent << " Normal: " << GetNormal() << std::endl;
   }
 
   bool PlaneGeometry::Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const
   {
     assert(this->IsBoundingBoxNull() == false);
 
     Point3D pt3d_units;
     Superclass::WorldToIndex(pt3d_mm, pt3d_units);
     pt2d_mm[0] = pt3d_units[0] * GetExtentInMM(0) / GetExtent(0);
     pt2d_mm[1] = pt3d_units[1] * GetExtentInMM(1) / GetExtent(1);
     pt3d_units[2] = 0;
     return this->GetBoundingBox()->IsInside(pt3d_units);
   }
 
   void PlaneGeometry::Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const
   {
     // pt2d_mm is measured from the origin of the world geometry (at leats it called form BaseRendere::Mouse...Event)
     Point3D pt3d_units;
     pt3d_units[0] = pt2d_mm[0] / (GetExtentInMM(0) / GetExtent(0));
     pt3d_units[1] = pt2d_mm[1] / (GetExtentInMM(1) / GetExtent(1));
     pt3d_units[2] = 0;
     // pt3d_units is a continuos index. We divided it with the Scale Factor (= spacing in x and y) to convert it from mm
     // to index units.
     //
     pt3d_mm = GetIndexToWorldTransform()->TransformPoint(pt3d_units);
     // now we convert the 3d index to a 3D world point in mm. We could have used IndexToWorld as well as
     // GetITW->Transform...
   }
 
   void PlaneGeometry::SetSizeInUnits(mitk::ScalarType width, mitk::ScalarType height)
   {
     ScalarType bounds[6] = {0, width, 0, height, 0, 1};
     ScalarType extent, newextentInMM;
     if (GetExtent(0) > 0)
     {
       extent = GetExtent(0);
       if (width > extent)
         newextentInMM = GetExtentInMM(0) / width * extent;
       else
         newextentInMM = GetExtentInMM(0) * extent / width;
       SetExtentInMM(0, newextentInMM);
     }
     if (GetExtent(1) > 0)
     {
       extent = GetExtent(1);
       if (width > extent)
         newextentInMM = GetExtentInMM(1) / height * extent;
       else
         newextentInMM = GetExtentInMM(1) * extent / height;
       SetExtentInMM(1, newextentInMM);
     }
     SetBounds(bounds);
   }
 
   bool PlaneGeometry::Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const
   {
     assert(this->IsBoundingBoxNull() == false);
 
     Point3D pt3d_units;
     Superclass::WorldToIndex(pt3d_mm, pt3d_units);
     pt3d_units[2] = 0;
     projectedPt3d_mm = GetIndexToWorldTransform()->TransformPoint(pt3d_units);
     return this->GetBoundingBox()->IsInside(pt3d_units);
   }
 
   bool PlaneGeometry::Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const
   {
     assert(this->IsBoundingBoxNull() == false);
 
     Vector3D vec3d_units;
     Superclass::WorldToIndex(vec3d_mm, vec3d_units);
     vec3d_units[2] = 0;
     projectedVec3d_mm = GetIndexToWorldTransform()->TransformVector(vec3d_units);
     return true;
   }
 
   bool PlaneGeometry::Project(const mitk::Point3D &atPt3d_mm,
                               const mitk::Vector3D &vec3d_mm,
                               mitk::Vector3D &projectedVec3d_mm) const
   {
     MITK_WARN << "Deprecated function! Call Project(vec3D,vec3D) instead.";
     assert(this->IsBoundingBoxNull() == false);
 
     Vector3D vec3d_units;
     Superclass::WorldToIndex(atPt3d_mm, vec3d_mm, vec3d_units);
     vec3d_units[2] = 0;
     projectedVec3d_mm = GetIndexToWorldTransform()->TransformVector(vec3d_units);
 
     Point3D pt3d_units;
     Superclass::WorldToIndex(atPt3d_mm, pt3d_units);
     return this->GetBoundingBox()->IsInside(pt3d_units);
   }
 
   bool PlaneGeometry::Map(const mitk::Point3D &atPt3d_mm,
                           const mitk::Vector3D &vec3d_mm,
                           mitk::Vector2D &vec2d_mm) const
   {
     Point2D pt2d_mm_start, pt2d_mm_end;
     Point3D pt3d_mm_end;
     bool inside = Map(atPt3d_mm, pt2d_mm_start);
     pt3d_mm_end = atPt3d_mm + vec3d_mm;
     inside &= Map(pt3d_mm_end, pt2d_mm_end);
     vec2d_mm = pt2d_mm_end - pt2d_mm_start;
     return inside;
   }
 
   void PlaneGeometry::Map(const mitk::Point2D & /*atPt2d_mm*/,
                           const mitk::Vector2D & /*vec2d_mm*/,
                           mitk::Vector3D & /*vec3d_mm*/) const
   {
     //@todo implement parallel to the other Map method!
     assert(false);
   }
 
   void PlaneGeometry::SetReferenceGeometry(const mitk::BaseGeometry *geometry) { m_ReferenceGeometry = geometry; }
   const mitk::BaseGeometry *PlaneGeometry::GetReferenceGeometry() const { return m_ReferenceGeometry; }
   bool PlaneGeometry::HasReferenceGeometry() const { return (m_ReferenceGeometry != nullptr); }
 } // namespace
diff --git a/Modules/Core/src/DataManagement/mitkSlicedGeometry3D.cpp b/Modules/Core/src/DataManagement/mitkSlicedGeometry3D.cpp
index 45461ae52e..ace7603c62 100644
--- a/Modules/Core/src/DataManagement/mitkSlicedGeometry3D.cpp
+++ b/Modules/Core/src/DataManagement/mitkSlicedGeometry3D.cpp
@@ -1,962 +1,962 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <itkSpatialOrientationAdapter.h>
 
 #include "mitkSlicedGeometry3D.h"
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkApplyTransformMatrixOperation.h"
 #include "mitkInteractionConst.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlaneOperation.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkRotationOperation.h"
 #include "mitkSliceNavigationController.h"
 
 const mitk::ScalarType PI = 3.14159265359;
 
 mitk::SlicedGeometry3D::SlicedGeometry3D()
   : m_EvenlySpaced(true), m_Slices(0), m_ReferenceGeometry(nullptr), m_SliceNavigationController(nullptr)
 {
   m_DirectionVector.Fill(0);
   this->InitializeSlicedGeometry(m_Slices);
 }
 
 mitk::SlicedGeometry3D::SlicedGeometry3D(const SlicedGeometry3D &other)
   : Superclass(other),
     m_EvenlySpaced(other.m_EvenlySpaced),
     m_Slices(other.m_Slices),
     m_ReferenceGeometry(other.m_ReferenceGeometry),
     m_SliceNavigationController(other.m_SliceNavigationController)
 {
   m_DirectionVector.Fill(0);
   SetSpacing(other.GetSpacing());
   SetDirectionVector(other.GetDirectionVector());
 
   if (m_EvenlySpaced)
   {
     assert(!other.m_PlaneGeometries.empty() && "This may happen when you use one of the old Initialize methods, which had a bool parameter that is implicitly casted to the number of slices now.");
     PlaneGeometry::Pointer geometry = other.m_PlaneGeometries[0]->Clone();
     assert(geometry.IsNotNull());
     SetPlaneGeometry(geometry, 0);
   }
   else
   {
     unsigned int s;
     for (s = 0; s < other.m_Slices; ++s)
     {
       if (other.m_PlaneGeometries[s].IsNull())
       {
         assert(other.m_EvenlySpaced);
         m_PlaneGeometries[s] = nullptr;
       }
       else
       {
         PlaneGeometry *geometry2D = other.m_PlaneGeometries[s]->Clone();
         assert(geometry2D != nullptr);
         SetPlaneGeometry(geometry2D, s);
       }
     }
   }
 }
 
 mitk::SlicedGeometry3D::~SlicedGeometry3D()
 {
 }
 
 mitk::PlaneGeometry *mitk::SlicedGeometry3D::GetPlaneGeometry(int s) const
 {
   mitk::PlaneGeometry::Pointer geometry2D = nullptr;
 
   if (this->IsValidSlice(s))
   {
     geometry2D = m_PlaneGeometries[s];
 
     // If (a) m_EvenlySpaced==true, (b) we don't have a PlaneGeometry stored
     // for the requested slice, and (c) the first slice (s=0)
     // is a PlaneGeometry instance, then we calculate the geometry of the
     // requested as the plane of the first slice shifted by m_Spacing[2]*s
     // in the direction of m_DirectionVector.
     if ((m_EvenlySpaced) && (geometry2D.IsNull()))
     {
       PlaneGeometry *firstSlice = m_PlaneGeometries[0];
 
       if (firstSlice != nullptr &&
           dynamic_cast<AbstractTransformGeometry *>(m_PlaneGeometries[0].GetPointer()) == nullptr)
       {
         if ((m_DirectionVector[0] == 0.0) && (m_DirectionVector[1] == 0.0) && (m_DirectionVector[2] == 0.0))
         {
           m_DirectionVector = firstSlice->GetNormal();
           m_DirectionVector.Normalize();
         }
 
         Vector3D direction;
         direction = m_DirectionVector * this->GetSpacing()[2];
 
         mitk::PlaneGeometry::Pointer requestedslice;
         requestedslice = static_cast<mitk::PlaneGeometry *>(firstSlice->Clone().GetPointer());
 
         requestedslice->SetOrigin(requestedslice->GetOrigin() + direction * s);
 
         geometry2D = requestedslice;
         m_PlaneGeometries[s] = geometry2D;
       }
     }
     return geometry2D;
   }
   else
   {
     return nullptr;
   }
 }
 
 const mitk::BoundingBox *mitk::SlicedGeometry3D::GetBoundingBox() const
 {
   assert(this->IsBoundingBoxNull() == false);
   return Superclass::GetBoundingBox();
 }
 
 bool mitk::SlicedGeometry3D::SetPlaneGeometry(mitk::PlaneGeometry *geometry2D, int s)
 {
   if (this->IsValidSlice(s))
   {
     m_PlaneGeometries[s] = geometry2D;
     m_PlaneGeometries[s]->SetReferenceGeometry(m_ReferenceGeometry);
     return true;
   }
   return false;
 }
 
 void mitk::SlicedGeometry3D::InitializeSlicedGeometry(unsigned int slices)
 {
   Superclass::Initialize();
   m_Slices = slices;
 
   PlaneGeometry::Pointer gnull = nullptr;
   m_PlaneGeometries.assign(m_Slices, gnull);
 
   Vector3D spacing;
   spacing.Fill(1.0);
   this->SetSpacing(spacing);
 
   m_DirectionVector.Fill(0);
 }
 
 void mitk::SlicedGeometry3D::InitializeEvenlySpaced(mitk::PlaneGeometry *geometry2D, unsigned int slices)
 {
   assert(geometry2D != nullptr);
   this->InitializeEvenlySpaced(geometry2D, geometry2D->GetExtentInMM(2) / geometry2D->GetExtent(2), slices);
 }
 
 void mitk::SlicedGeometry3D::InitializeEvenlySpaced(mitk::PlaneGeometry *geometry2D,
                                                     mitk::ScalarType zSpacing,
                                                     unsigned int slices)
 {
   assert(geometry2D != nullptr);
   assert(geometry2D->GetExtent(0) > 0);
   assert(geometry2D->GetExtent(1) > 0);
 
   geometry2D->Register();
 
   Superclass::Initialize();
   m_Slices = slices;
 
   BoundingBox::BoundsArrayType bounds = geometry2D->GetBounds();
   bounds[4] = 0;
   bounds[5] = slices;
 
   // clear and reserve
   PlaneGeometry::Pointer gnull = nullptr;
   m_PlaneGeometries.assign(m_Slices, gnull);
 
   Vector3D directionVector = geometry2D->GetAxisVector(2);
   directionVector.Normalize();
   directionVector *= zSpacing;
 
   // Normally we should use the following four lines to create a copy of
   // the transform contrained in geometry2D, because it may not be changed
   // by us. But we know that SetSpacing creates a new transform without
   // changing the old (coming from geometry2D), so we can use the fifth
   // line instead. We check this at (**).
   //
   // AffineTransform3D::Pointer transform = AffineTransform3D::New();
   // transform->SetMatrix(geometry2D->GetIndexToWorldTransform()->GetMatrix());
   // transform->SetOffset(geometry2D->GetIndexToWorldTransform()->GetOffset());
   // SetIndexToWorldTransform(transform);
 
   this->SetIndexToWorldTransform(geometry2D->GetIndexToWorldTransform());
 
   mitk::Vector3D spacing;
   FillVector3D(spacing, geometry2D->GetExtentInMM(0) / bounds[1], geometry2D->GetExtentInMM(1) / bounds[3], zSpacing);
 
   this->SetDirectionVector(directionVector);
   this->SetBounds(bounds);
   this->SetPlaneGeometry(geometry2D, 0);
   this->SetSpacing(spacing, true);
   this->SetEvenlySpaced();
 
   // this->SetTimeBounds( geometry2D->GetTimeBounds() );
 
   assert(this->GetIndexToWorldTransform() != geometry2D->GetIndexToWorldTransform()); // (**) see above.
 
   this->SetFrameOfReferenceID(geometry2D->GetFrameOfReferenceID());
   this->SetImageGeometry(geometry2D->GetImageGeometry());
 
   geometry2D->UnRegister();
 }
 
 void mitk::SlicedGeometry3D::InitializePlanes(const mitk::BaseGeometry *geometry3D,
                                               mitk::PlaneGeometry::PlaneOrientation planeorientation,
                                               bool top,
                                               bool frontside,
                                               bool rotated)
 {
   m_ReferenceGeometry = geometry3D;
 
   PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
   planeGeometry->InitializeStandardPlane(geometry3D, top, planeorientation, frontside, rotated);
 
   int worldAxis =
       planeorientation == PlaneGeometry::Sagittal ? 0 :
-      planeorientation == PlaneGeometry::Frontal  ? 1 : 2;
+      planeorientation == PlaneGeometry::Coronal  ? 1 : 2;
 
   // Inspired by:
   // http://www.na-mic.org/Wiki/index.php/Coordinate_System_Conversion_Between_ITK_and_Slicer3
 
   mitk::AffineTransform3D::MatrixType matrix = geometry3D->GetIndexToWorldTransform()->GetMatrix();
   matrix.GetVnlMatrix().normalize_columns();
   mitk::AffineTransform3D::MatrixType::InternalMatrixType inverseMatrix = matrix.GetTranspose();
 
   int dominantAxis = planeGeometry->CalculateDominantAxes(inverseMatrix).at(worldAxis);
   ScalarType viewSpacing = geometry3D->GetSpacing()[dominantAxis];
 
   /// Although the double value returned by GetExtent() holds a round number,
   /// you need to add 0.5 to safely convert it to unsigned it. I have seen a
   /// case when the result was less by one without this.
   auto slices = static_cast<unsigned int>(geometry3D->GetExtent(dominantAxis) + 0.5);
   if ( slices == 0 && geometry3D->GetExtent(dominantAxis) > 0) {
       // require at least one slice if there is _some_ extent
       slices = 1;
   }
 
 #ifndef NDEBUG
   int upDirection = itk::Function::Sign(inverseMatrix[dominantAxis][worldAxis]);
 
   /// The normal vector of an imaginary plane that points from the world origin (bottom left back
   /// corner or the world, with the lowest physical coordinates) towards the inside of the volume,
   /// along the renderer axis. Length is the slice thickness.
   Vector3D worldPlaneNormal = inverseMatrix.get_row(dominantAxis) * (upDirection * viewSpacing);
 
   /// The normal of the standard plane geometry just created.
   Vector3D standardPlaneNormal = planeGeometry->GetNormal();
 
   /// The standard plane must be parallel to the 'world plane'. The normal of the standard plane
   /// must point against the world plane if and only if 'top' is 'false'. The length of the
   /// standard plane normal must be equal to the slice thickness.
   assert((standardPlaneNormal - (top ? 1.0 : -1.0) * worldPlaneNormal).GetSquaredNorm() < 0.000001);
 #endif
 
   this->InitializeEvenlySpaced(planeGeometry, viewSpacing, slices);
 
 #ifndef NDEBUG
   /// The standard plane normal and the z axis vector of the sliced geometry must point in
   /// the same direction.
   Vector3D zAxisVector = this->GetAxisVector(2);
   Vector3D upscaledStandardPlaneNormal = standardPlaneNormal;
   upscaledStandardPlaneNormal *= slices;
   assert((zAxisVector - upscaledStandardPlaneNormal).GetSquaredNorm() < 0.000001);
 
   /// You can use this test is to check the handedness of the coordinate system of the current
   /// geometry. In principle, you can use either left- or right-handed coordinate systems, but
   /// you normally want it to be consistent, that is the handedness should be the same across
   /// the renderers of the same viewer.
 //  ScalarType det = vnl_det(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix());
 //  MITK_DEBUG << "world axis: " << worldAxis << (det > 0 ? " ; right-handed" : " ; left-handed");
 #endif
 }
 
 void mitk::SlicedGeometry3D::ReinitializePlanes(const Point3D &center, const Point3D &referencePoint)
 {
   // Need a reference frame to align the rotated planes
   if (!m_ReferenceGeometry)
   {
     return;
   }
 
   // Get first plane of plane stack
   PlaneGeometry *firstPlane = m_PlaneGeometries[0];
 
   // If plane stack is empty, exit
   if (!firstPlane || dynamic_cast<AbstractTransformGeometry *>(firstPlane))
   {
     return;
   }
 
   // Calculate the "directed" spacing when taking the plane (defined by its axes
   // vectors and normal) as the reference coordinate frame.
   //
   // This is done by calculating the radius of the ellipsoid defined by the
   // original volume spacing axes, in the direction of the respective axis of the
   // reference frame.
   mitk::Vector3D axis0 = firstPlane->GetAxisVector(0);
   mitk::Vector3D axis1 = firstPlane->GetAxisVector(1);
   mitk::Vector3D normal = firstPlane->GetNormal();
   normal.Normalize();
 
   Vector3D spacing;
   spacing[0] = this->CalculateSpacing(axis0);
   spacing[1] = this->CalculateSpacing(axis1);
   spacing[2] = this->CalculateSpacing(normal);
 
   Superclass::SetSpacing(spacing);
 
   // Now we need to calculate the number of slices in the plane's normal
   // direction, so that the entire volume is covered. This is done by first
   // calculating the dot product between the volume diagonal (the maximum
   // distance inside the volume) and the normal, and dividing this value by
   // the directed spacing calculated above.
   ScalarType directedExtent = std::abs(m_ReferenceGeometry->GetExtentInMM(0) * normal[0]) +
                               std::abs(m_ReferenceGeometry->GetExtentInMM(1) * normal[1]) +
                               std::abs(m_ReferenceGeometry->GetExtentInMM(2) * normal[2]);
 
   if (directedExtent >= spacing[2])
   {
     m_Slices = static_cast<unsigned int>(directedExtent / spacing[2] + 0.5);
   }
   else
   {
     m_Slices = 1;
   }
 
   // The origin of our "first plane" needs to be adapted to this new extent.
   // To achieve this, we first calculate the current distance to the volume's
   // center, and then shift the origin in the direction of the normal by the
   // difference between this distance and half of the new extent.
   double centerOfRotationDistance = firstPlane->SignedDistanceFromPlane(center);
 
   if (centerOfRotationDistance > 0)
   {
     firstPlane->SetOrigin(firstPlane->GetOrigin() + normal * (centerOfRotationDistance - directedExtent / 2.0));
     m_DirectionVector = normal;
   }
   else
   {
     firstPlane->SetOrigin(firstPlane->GetOrigin() + normal * (directedExtent / 2.0 + centerOfRotationDistance));
     m_DirectionVector = -normal;
   }
 
   // Now we adjust this distance according with respect to the given reference
   // point: we need to make sure that the point is touched by one slice of the
   // new slice stack.
   double referencePointDistance = firstPlane->SignedDistanceFromPlane(referencePoint);
 
   auto referencePointSlice = static_cast<int>(referencePointDistance / spacing[2]);
 
   double alignmentValue = referencePointDistance / spacing[2] - referencePointSlice;
 
   firstPlane->SetOrigin(firstPlane->GetOrigin() + normal * alignmentValue * spacing[2]);
 
   // Finally, we can clear the previous geometry stack and initialize it with
   // our re-initialized "first plane".
   m_PlaneGeometries.assign(m_Slices, PlaneGeometry::Pointer(nullptr));
 
   if (m_Slices > 0)
   {
     m_PlaneGeometries[0] = firstPlane;
   }
 
   // Reinitialize SNC with new number of slices
   m_SliceNavigationController->GetSlice()->SetSteps(m_Slices);
 
   this->Modified();
 }
 
 double mitk::SlicedGeometry3D::CalculateSpacing(const mitk::Vector3D &d) const
 {
   // Need the spacing of the underlying dataset / geometry
   if (!m_ReferenceGeometry)
   {
     return 1.0;
   }
 
   const mitk::Vector3D &spacing = m_ReferenceGeometry->GetSpacing();
   return SlicedGeometry3D::CalculateSpacing(spacing, d);
 }
 
 double mitk::SlicedGeometry3D::CalculateSpacing(const mitk::Vector3D &spacing, const mitk::Vector3D &d)
 {
   // The following can be derived from the ellipsoid equation
   //
   //   1 = x^2/a^2 + y^2/b^2 + z^2/c^2
   //
   // where (a,b,c) = spacing of original volume (ellipsoid radii)
   // and   (x,y,z) = scaled coordinates of vector d (according to ellipsoid)
   //
   double scaling = d[0] * d[0] / (spacing[0] * spacing[0]) + d[1] * d[1] / (spacing[1] * spacing[1]) +
                    d[2] * d[2] / (spacing[2] * spacing[2]);
 
   scaling = sqrt(scaling);
 
   return (sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]) / scaling);
 }
 
 mitk::Vector3D mitk::SlicedGeometry3D::AdjustNormal(const mitk::Vector3D &normal) const
 {
   TransformType::Pointer inverse = TransformType::New();
   m_ReferenceGeometry->GetIndexToWorldTransform()->GetInverse(inverse);
 
   Vector3D transformedNormal = inverse->TransformVector(normal);
 
   transformedNormal.Normalize();
   return transformedNormal;
 }
 
 void mitk::SlicedGeometry3D::SetImageGeometry(const bool isAnImageGeometry)
 {
   Superclass::SetImageGeometry(isAnImageGeometry);
 
   unsigned int s;
   for (s = 0; s < m_Slices; ++s)
   {
     mitk::BaseGeometry *geometry = m_PlaneGeometries[s];
     if (geometry != nullptr)
     {
       geometry->SetImageGeometry(isAnImageGeometry);
     }
   }
 }
 
 void mitk::SlicedGeometry3D::ChangeImageGeometryConsideringOriginOffset(const bool isAnImageGeometry)
 {
   unsigned int s;
   for (s = 0; s < m_Slices; ++s)
   {
     mitk::BaseGeometry *geometry = m_PlaneGeometries[s];
     if (geometry != nullptr)
     {
       geometry->ChangeImageGeometryConsideringOriginOffset(isAnImageGeometry);
     }
   }
 
   Superclass::ChangeImageGeometryConsideringOriginOffset(isAnImageGeometry);
 }
 
 bool mitk::SlicedGeometry3D::IsValidSlice(int s) const
 {
   return ((s >= 0) && (s < (int)m_Slices));
 }
 
 const mitk::BaseGeometry *mitk::SlicedGeometry3D::GetReferenceGeometry() const
 {
   return m_ReferenceGeometry;
 }
 
 void mitk::SlicedGeometry3D::SetReferenceGeometry(const BaseGeometry *referenceGeometry)
 {
   m_ReferenceGeometry = referenceGeometry;
 
   std::vector<PlaneGeometry::Pointer>::iterator it;
 
   for (it = m_PlaneGeometries.begin(); it != m_PlaneGeometries.end(); ++it)
   {
     (*it)->SetReferenceGeometry(referenceGeometry);
   }
 }
 
 bool mitk::SlicedGeometry3D::HasReferenceGeometry() const
 {
   return ( m_ReferenceGeometry != nullptr );
 }
 
 void mitk::SlicedGeometry3D::PreSetSpacing(const mitk::Vector3D &aSpacing)
 {
   bool hasEvenlySpacedPlaneGeometry = false;
   mitk::Point3D origin;
   mitk::Vector3D rightDV, bottomDV;
   BoundingBox::BoundsArrayType bounds;
 
   // Check for valid spacing
   if (!(aSpacing[0] > 0 && aSpacing[1] > 0 && aSpacing[2] > 0))
   {
     mitkThrow() << "You try to set a spacing with at least one element equal or "
                    "smaller to \"0\". This might lead to a crash during rendering. Please double"
                    " check your data!";
   }
 
   // In case of evenly-spaced data: re-initialize instances of PlaneGeometry,
   // since the spacing influences them
   if ((m_EvenlySpaced) && (m_PlaneGeometries.size() > 0))
   {
     const PlaneGeometry *planeGeometry = m_PlaneGeometries[0];
 
     if (planeGeometry && !dynamic_cast<const AbstractTransformGeometry *>(planeGeometry))
     {
       this->WorldToIndex(planeGeometry->GetOrigin(), origin);
       this->WorldToIndex(planeGeometry->GetAxisVector(0), rightDV);
       this->WorldToIndex(planeGeometry->GetAxisVector(1), bottomDV);
 
       bounds = planeGeometry->GetBounds();
       hasEvenlySpacedPlaneGeometry = true;
     }
   }
 
   BaseGeometry::_SetSpacing(aSpacing);
 
   mitk::PlaneGeometry::Pointer firstGeometry;
 
   // In case of evenly-spaced data: re-initialize instances of PlaneGeometry,
   // since the spacing influences them
   if (hasEvenlySpacedPlaneGeometry)
   {
     // create planeGeometry according to new spacing
     this->IndexToWorld(origin, origin);
     this->IndexToWorld(rightDV, rightDV);
     this->IndexToWorld(bottomDV, bottomDV);
 
     mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
     planeGeometry->SetImageGeometry(this->GetImageGeometry());
 
     planeGeometry->SetReferenceGeometry(m_ReferenceGeometry);
 
     // Store spacing, as Initialize... needs a pointer
     mitk::Vector3D lokalSpacing = this->GetSpacing();
     planeGeometry->InitializeStandardPlane(rightDV.GetVnlVector(), bottomDV.GetVnlVector(), &lokalSpacing);
     planeGeometry->SetOrigin(origin);
     planeGeometry->SetBounds(bounds);
 
     firstGeometry = planeGeometry;
   }
   else if ((m_EvenlySpaced) && (m_PlaneGeometries.size() > 0))
   {
     firstGeometry = m_PlaneGeometries[0].GetPointer();
   }
 
   // clear and reserve
   PlaneGeometry::Pointer gnull = nullptr;
   m_PlaneGeometries.assign(m_Slices, gnull);
 
   if (m_Slices > 0)
   {
     m_PlaneGeometries[0] = firstGeometry;
   }
 
   this->Modified();
 }
 
 void mitk::SlicedGeometry3D::SetSliceNavigationController(SliceNavigationController *snc)
 {
   m_SliceNavigationController = snc;
 }
 
 mitk::SliceNavigationController *mitk::SlicedGeometry3D::GetSliceNavigationController()
 {
   return m_SliceNavigationController;
 }
 
 void mitk::SlicedGeometry3D::SetEvenlySpaced(bool on)
 {
   if (m_EvenlySpaced != on)
   {
     m_EvenlySpaced = on;
     this->Modified();
   }
 }
 
 void mitk::SlicedGeometry3D::SetDirectionVector(const mitk::Vector3D &directionVector)
 {
   Vector3D newDir = directionVector;
   newDir.Normalize();
   if (newDir != m_DirectionVector)
   {
     m_DirectionVector = newDir;
     this->Modified();
   }
 }
 
 // void
 // mitk::SlicedGeometry3D::SetTimeBounds( const mitk::TimeBounds& timebounds )
 //{
 //  Superclass::SetTimeBounds( timebounds );
 //
 //  unsigned int s;
 //  for ( s = 0; s < m_Slices; ++s )
 //  {
 //    if(m_Geometry2Ds[s].IsNotNull())
 //    {
 //      m_Geometry2Ds[s]->SetTimeBounds( timebounds );
 //    }
 //  }
 //  m_TimeBounds = timebounds;
 //}
 
 itk::LightObject::Pointer mitk::SlicedGeometry3D::InternalClone() const
 {
   Self::Pointer newGeometry = new SlicedGeometry3D(*this);
   newGeometry->UnRegister();
   return newGeometry.GetPointer();
 }
 
 void mitk::SlicedGeometry3D::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
   Superclass::PrintSelf(os, indent);
   os << indent << " EvenlySpaced: " << m_EvenlySpaced << std::endl;
   if (m_EvenlySpaced)
   {
     os << indent << " DirectionVector: " << m_DirectionVector << std::endl;
   }
   os << indent << " Slices: " << m_Slices << std::endl;
 
   os << std::endl;
   os << indent << " GetPlaneGeometry(0): ";
   if (this->GetPlaneGeometry(0) == nullptr)
   {
     os << "nullptr" << std::endl;
   }
   else
   {
     this->GetPlaneGeometry(0)->Print(os, indent);
   }
 }
 
 void mitk::SlicedGeometry3D::ExecuteOperation(Operation *operation)
 {
   PlaneGeometry::Pointer geometry2D;
   ApplyTransformMatrixOperation *applyMatrixOp;
   Point3D center;
 
   switch (operation->GetOperationType())
   {
     case OpNOTHING:
       break;
 
     case OpROTATE:
       if (m_EvenlySpaced)
       {
         // Need a reference frame to align the rotation
         if (m_ReferenceGeometry)
         {
           // Clear all generated geometries and then rotate only the first slice.
           // The other slices will be re-generated on demand
 
           // Save first slice
           PlaneGeometry::Pointer geometry2D = m_PlaneGeometries[0];
 
           auto *rotOp = dynamic_cast<RotationOperation *>(operation);
 
           // Generate a RotationOperation using the dataset center instead of
           // the supplied rotation center. This is necessary so that the rotated
           // zero-plane does not shift away. The supplied center is instead used
           // to adjust the slice stack afterwards.
           Point3D center = m_ReferenceGeometry->GetCenter();
 
           RotationOperation centeredRotation(
             rotOp->GetOperationType(), center, rotOp->GetVectorOfRotation(), rotOp->GetAngleOfRotation());
 
           // Rotate first slice
           geometry2D->ExecuteOperation(&centeredRotation);
 
           // Clear the slice stack and adjust it according to the center of
           // the dataset and the supplied rotation center (see documentation of
           // ReinitializePlanes)
           this->ReinitializePlanes(center, rotOp->GetCenterOfRotation());
 
           geometry2D->SetSpacing(this->GetSpacing());
 
           if (m_SliceNavigationController)
           {
             m_SliceNavigationController->SelectSliceByPoint(rotOp->GetCenterOfRotation());
             m_SliceNavigationController->AdjustSliceStepperRange();
           }
 
           BaseGeometry::ExecuteOperation(&centeredRotation);
         }
         else
         {
           // we also have to consider the case, that there is no reference geometry available.
           if (m_PlaneGeometries.size() > 0)
           {
             // Reach through to all slices in my container
             for (auto iter = m_PlaneGeometries.begin(); iter != m_PlaneGeometries.end(); ++iter)
             {
               // Test for empty slices, which can happen if evenly spaced geometry
               if ((*iter).IsNotNull())
               {
                 (*iter)->ExecuteOperation(operation);
               }
             }
 
             // rotate overall geometry
             auto *rotOp = dynamic_cast<RotationOperation *>(operation);
             BaseGeometry::ExecuteOperation(rotOp);
           }
         }
       }
       else
       {
         // Reach through to all slices
         for (auto iter = m_PlaneGeometries.begin(); iter != m_PlaneGeometries.end(); ++iter)
         {
           (*iter)->ExecuteOperation(operation);
         }
       }
       break;
 
     case OpORIENT:
       if (m_EvenlySpaced)
       {
         // get operation data
         auto *planeOp = dynamic_cast<PlaneOperation *>(operation);
 
         // Get first slice
         PlaneGeometry::Pointer planeGeometry = m_PlaneGeometries[0];
 
         // Need a PlaneGeometry, a PlaneOperation and a reference frame to
         // carry out the re-orientation. If not all avaialble, stop here
         if (!m_ReferenceGeometry ||
             (!planeGeometry || dynamic_cast<AbstractTransformGeometry *>(planeGeometry.GetPointer())) || !planeOp)
         {
           break;
         }
 
         // General Behavior:
         // Clear all generated geometries and then rotate only the first slice.
         // The other slices will be re-generated on demand
 
         //
         // 1st Step: Reorient Normal Vector of first plane
         //
         Point3D center = planeOp->GetPoint(); // m_ReferenceGeometry->GetCenter();
         mitk::Vector3D currentNormal = planeGeometry->GetNormal();
         mitk::Vector3D newNormal;
         if (planeOp->AreAxisDefined())
         {
           // If planeOp was defined by one centerpoint and two axis vectors
           newNormal = CrossProduct(planeOp->GetAxisVec0(), planeOp->GetAxisVec1());
         }
         else
         {
           // If planeOp was defined by one centerpoint and one normal vector
           newNormal = planeOp->GetNormal();
         }
 
         // Get Rotation axis und angle
         currentNormal.Normalize();
         newNormal.Normalize();
         ScalarType rotationAngle = angle(currentNormal.GetVnlVector(), newNormal.GetVnlVector());
 
         rotationAngle *= 180.0 / vnl_math::pi; // from rad to deg
         Vector3D rotationAxis = itk::CrossProduct(currentNormal, newNormal);
         if (std::abs(rotationAngle - 180) < mitk::eps)
         {
           // current Normal and desired normal are not linear independent!!(e.g 1,0,0 and -1,0,0).
           // Rotation Axis should be ANY vector that is 90� to current Normal
           mitk::Vector3D helpNormal;
           helpNormal = currentNormal;
           helpNormal[0] += 1;
           helpNormal[1] -= 1;
           helpNormal[2] += 1;
           helpNormal.Normalize();
           rotationAxis = itk::CrossProduct(helpNormal, currentNormal);
         }
 
         RotationOperation centeredRotation(mitk::OpROTATE, center, rotationAxis, rotationAngle);
 
         // Rotate first slice
         planeGeometry->ExecuteOperation(&centeredRotation);
 
         // Reinitialize planes and select slice, if my rotations are all done.
         if (!planeOp->AreAxisDefined())
         {
           // Clear the slice stack and adjust it according to the center of
           // rotation and plane position (see documentation of ReinitializePlanes)
           this->ReinitializePlanes(center, planeOp->GetPoint());
           planeGeometry->SetSpacing(this->GetSpacing());
 
           if (m_SliceNavigationController)
           {
             m_SliceNavigationController->SelectSliceByPoint(planeOp->GetPoint());
             m_SliceNavigationController->AdjustSliceStepperRange();
           }
         }
 
         // Also apply rotation on the slicedGeometry - Geometry3D (Bounding geometry)
         BaseGeometry::ExecuteOperation(&centeredRotation);
 
         //
         // 2nd step. If axis vectors were defined, rotate the plane around its normal to fit these
         //
 
         if (planeOp->AreAxisDefined())
         {
           mitk::Vector3D vecAxixNew = planeOp->GetAxisVec0();
           vecAxixNew.Normalize();
           mitk::Vector3D VecAxisCurr = planeGeometry->GetAxisVector(0);
           VecAxisCurr.Normalize();
 
           ScalarType rotationAngle = angle(VecAxisCurr.GetVnlVector(), vecAxixNew.GetVnlVector());
           rotationAngle = rotationAngle * 180 / PI; // Rad to Deg
 
           // we rotate around the normal of the plane, but we do not know, if we need to rotate clockwise
           // or anti-clockwise. So we rotate around the crossproduct of old and new Axisvector.
           // Since both axis vectors lie in the plane, the crossproduct is the planes normal or the negative planes
           // normal
 
           rotationAxis = itk::CrossProduct(VecAxisCurr, vecAxixNew);
           if (std::abs(rotationAngle - 180) < mitk::eps)
           {
             // current axisVec and desired axisVec are not linear independent!!(e.g 1,0,0 and -1,0,0).
             // Rotation Axis can be just plane Normal. (have to rotate by 180�)
             rotationAxis = newNormal;
           }
 
           // Perfom Rotation
           mitk::RotationOperation op(mitk::OpROTATE, center, rotationAxis, rotationAngle);
           planeGeometry->ExecuteOperation(&op);
 
           // Apply changes on first slice to whole slice stack
           this->ReinitializePlanes(center, planeOp->GetPoint());
           planeGeometry->SetSpacing(this->GetSpacing());
 
           if (m_SliceNavigationController)
           {
             m_SliceNavigationController->SelectSliceByPoint(planeOp->GetPoint());
             m_SliceNavigationController->AdjustSliceStepperRange();
           }
 
           // Also apply rotation on the slicedGeometry - Geometry3D (Bounding geometry)
           BaseGeometry::ExecuteOperation(&op);
         }
       }
       else
       {
         // Reach through to all slices
         for (auto iter = m_PlaneGeometries.begin(); iter != m_PlaneGeometries.end(); ++iter)
         {
           (*iter)->ExecuteOperation(operation);
         }
       }
       break;
 
     case OpRESTOREPLANEPOSITION:
       if (m_EvenlySpaced)
       {
         // Save first slice
         PlaneGeometry::Pointer planeGeometry = m_PlaneGeometries[0];
 
         auto *restorePlaneOp = dynamic_cast<RestorePlanePositionOperation *>(operation);
 
         // Need a PlaneGeometry, a PlaneOperation and a reference frame to
         // carry out the re-orientation
         if (m_ReferenceGeometry &&
             (planeGeometry && dynamic_cast<AbstractTransformGeometry *>(planeGeometry.GetPointer()) == nullptr) &&
             restorePlaneOp)
         {
           // Clear all generated geometries and then rotate only the first slice.
           // The other slices will be re-generated on demand
 
           // Rotate first slice
           planeGeometry->ExecuteOperation(restorePlaneOp);
 
           m_DirectionVector = restorePlaneOp->GetDirectionVector();
 
           double centerOfRotationDistance = planeGeometry->SignedDistanceFromPlane(m_ReferenceGeometry->GetCenter());
 
           if (centerOfRotationDistance <= 0)
           {
             m_DirectionVector = -m_DirectionVector;
           }
 
           Vector3D spacing = restorePlaneOp->GetSpacing();
 
           Superclass::SetSpacing(spacing);
 
           // /*Now we need to calculate the number of slices in the plane's normal
           // direction, so that the entire volume is covered. This is done by first
           // calculating the dot product between the volume diagonal (the maximum
           // distance inside the volume) and the normal, and dividing this value by
           // the directed spacing calculated above.*/
           ScalarType directedExtent = std::abs(m_ReferenceGeometry->GetExtentInMM(0) * m_DirectionVector[0]) +
                                       std::abs(m_ReferenceGeometry->GetExtentInMM(1) * m_DirectionVector[1]) +
                                       std::abs(m_ReferenceGeometry->GetExtentInMM(2) * m_DirectionVector[2]);
 
           if (directedExtent >= spacing[2])
           {
             m_Slices = static_cast<unsigned int>(directedExtent / spacing[2] + 0.5);
           }
           else
           {
             m_Slices = 1;
           }
 
           m_PlaneGeometries.assign(m_Slices, PlaneGeometry::Pointer(nullptr));
 
           if (m_Slices > 0)
           {
             m_PlaneGeometries[0] = planeGeometry;
           }
 
           m_SliceNavigationController->GetSlice()->SetSteps(m_Slices);
 
           this->Modified();
 
           // End Reinitialization
 
           if (m_SliceNavigationController)
           {
             m_SliceNavigationController->GetSlice()->SetPos(restorePlaneOp->GetPos());
             m_SliceNavigationController->AdjustSliceStepperRange();
           }
           BaseGeometry::ExecuteOperation(restorePlaneOp);
         }
       }
       else
       {
         // Reach through to all slices
         for (auto iter = m_PlaneGeometries.begin(); iter != m_PlaneGeometries.end(); ++iter)
         {
           (*iter)->ExecuteOperation(operation);
         }
       }
       break;
 
     case OpAPPLYTRANSFORMMATRIX:
 
       // Clear all generated geometries and then transform only the first slice.
       // The other slices will be re-generated on demand
 
       // Save first slice
       geometry2D = m_PlaneGeometries[0];
 
       applyMatrixOp = dynamic_cast<ApplyTransformMatrixOperation *>(operation);
 
       // Apply transformation to first plane
       geometry2D->ExecuteOperation(applyMatrixOp);
 
       // Generate a ApplyTransformMatrixOperation using the dataset center instead of
       // the supplied rotation center. The supplied center is instead used to adjust the
       // slice stack afterwards (see OpROTATE).
       center = m_ReferenceGeometry->GetCenter();
 
       // Clear the slice stack and adjust it according to the center of
       // the dataset and the supplied rotation center (see documentation of
       // ReinitializePlanes)
       this->ReinitializePlanes(center, applyMatrixOp->GetReferencePoint());
 
       BaseGeometry::ExecuteOperation(applyMatrixOp);
       break;
 
     default: // let handle by base class if we don't do anything
       BaseGeometry::ExecuteOperation(operation);
   }
 
   this->Modified();
 }
diff --git a/Modules/Core/src/DataManagement/mitkTemporoSpatialStringProperty.cpp b/Modules/Core/src/DataManagement/mitkTemporoSpatialStringProperty.cpp
index 845d8bd4d3..5d9649c5b8 100644
--- a/Modules/Core/src/DataManagement/mitkTemporoSpatialStringProperty.cpp
+++ b/Modules/Core/src/DataManagement/mitkTemporoSpatialStringProperty.cpp
@@ -1,499 +1,493 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <iterator>
 #include <set>
+#include <type_traits>
 
 #include "mitkTemporoSpatialStringProperty.h"
 
-#include <boost/property_tree/json_parser.hpp>
-#include <boost/property_tree/ptree.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
+#include <nlohmann/json.hpp>
+
+using namespace nlohmann;
 
 mitk::TemporoSpatialStringProperty::TemporoSpatialStringProperty(const char *s)
 {
   if (s)
   {
     SliceMapType slices{{0, s}};
 
     m_Values.insert(std::make_pair(0, slices));
   }
 }
 
 mitk::TemporoSpatialStringProperty::TemporoSpatialStringProperty(const std::string &s)
 {
   SliceMapType slices{{0, s}};
 
   m_Values.insert(std::make_pair(0, slices));
 }
 
 mitk::TemporoSpatialStringProperty::TemporoSpatialStringProperty(const TemporoSpatialStringProperty &other)
   : BaseProperty(other), m_Values(other.m_Values)
 {
 }
 
 bool mitk::TemporoSpatialStringProperty::IsEqual(const BaseProperty &property) const
 {
   return this->m_Values == static_cast<const Self &>(property).m_Values;
 }
 
 bool mitk::TemporoSpatialStringProperty::Assign(const BaseProperty &property)
 {
   this->m_Values = static_cast<const Self &>(property).m_Values;
   return true;
 }
 
 std::string mitk::TemporoSpatialStringProperty::GetValueAsString() const
 {
   return GetValue();
 }
 
 bool mitk::TemporoSpatialStringProperty::IsUniform() const
 {
   auto refValue = this->GetValue();
 
   for (const auto& timeStep : m_Values)
   {
     auto finding = std::find_if_not(timeStep.second.begin(), timeStep.second.end(), [&refValue](const mitk::TemporoSpatialStringProperty::SliceMapType::value_type& val) { return val.second == refValue; });
     if (finding != timeStep.second.end())
     {
       return false;
     }
   }
 
   return true;
 }
 
 itk::LightObject::Pointer mitk::TemporoSpatialStringProperty::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   result->UnRegister();
   return result;
 }
 
 mitk::TemporoSpatialStringProperty::ValueType mitk::TemporoSpatialStringProperty::GetValue() const
 {
   std::string result = "";
 
   if (!m_Values.empty())
   {
     if (!m_Values.begin()->second.empty())
     {
       result = m_Values.begin()->second.begin()->second;
     }
   }
   return result;
 };
 
 std::pair<bool, mitk::TemporoSpatialStringProperty::ValueType> mitk::TemporoSpatialStringProperty::CheckValue(
   const TimeStepType &timeStep, const IndexValueType &zSlice, bool allowCloseTime, bool allowCloseSlice) const
 {
   std::string value = "";
   bool found = false;
 
   auto timeIter = m_Values.find(timeStep);
   auto timeEnd = m_Values.end();
   if (timeIter == timeEnd && allowCloseTime)
   { // search for closest time step (earlier preverd)
     timeIter = m_Values.upper_bound(timeStep);
     if (timeIter != m_Values.begin())
     { // there is a key lower than time step
       timeIter = std::prev(timeIter);
     }
   }
 
   if (timeIter != timeEnd)
   {
     const SliceMapType &slices = timeIter->second;
 
     auto sliceIter = slices.find(zSlice);
     auto sliceEnd = slices.end();
     if (sliceIter == sliceEnd && allowCloseSlice)
     { // search for closest slice (earlier preverd)
       sliceIter = slices.upper_bound(zSlice);
       if (sliceIter != slices.begin())
       { // there is a key lower than slice
         sliceIter = std::prev(sliceIter);
       }
     }
 
     if (sliceIter != sliceEnd)
     {
       value = sliceIter->second;
       found = true;
     }
   }
 
   return std::make_pair(found, value);
 };
 
 mitk::TemporoSpatialStringProperty::ValueType mitk::TemporoSpatialStringProperty::GetValue(const TimeStepType &timeStep,
                                                                                            const IndexValueType &zSlice,
                                                                                            bool allowCloseTime,
                                                                                            bool allowCloseSlice) const
 {
   return CheckValue(timeStep, zSlice, allowCloseTime, allowCloseSlice).second;
 };
 
 mitk::TemporoSpatialStringProperty::ValueType mitk::TemporoSpatialStringProperty::GetValueBySlice(
   const IndexValueType &zSlice, bool allowClose) const
 {
   return GetValue(0, zSlice, true, allowClose);
 };
 
 mitk::TemporoSpatialStringProperty::ValueType mitk::TemporoSpatialStringProperty::GetValueByTimeStep(
   const TimeStepType &timeStep, bool allowClose) const
 {
   return GetValue(timeStep, 0, allowClose, true);
 };
 
 bool mitk::TemporoSpatialStringProperty::HasValue() const
 {
   return !m_Values.empty();
 };
 
 bool mitk::TemporoSpatialStringProperty::HasValue(const TimeStepType &timeStep,
                                                   const IndexValueType &zSlice,
                                                   bool allowCloseTime,
                                                   bool allowCloseSlice) const
 {
   return CheckValue(timeStep, zSlice, allowCloseTime, allowCloseSlice).first;
 };
 
 bool mitk::TemporoSpatialStringProperty::HasValueBySlice(const IndexValueType &zSlice, bool allowClose) const
 {
   return HasValue(0, zSlice, true, allowClose);
 };
 
 bool mitk::TemporoSpatialStringProperty::HasValueByTimeStep(const TimeStepType &timeStep, bool allowClose) const
 {
   return HasValue(timeStep, 0, allowClose, true);
 };
 
 std::vector<mitk::TemporoSpatialStringProperty::IndexValueType> mitk::TemporoSpatialStringProperty::GetAvailableSlices() const
 {
   std::set<IndexValueType> uniqueSlices;
 
   for (const auto& timeStep : m_Values)
   {
     for (const auto& slice : timeStep.second)
     {
       uniqueSlices.insert(slice.first);
     }
   }
 
   return std::vector<IndexValueType>(std::begin(uniqueSlices), std::end(uniqueSlices));
 }
 
 std::vector<mitk::TemporoSpatialStringProperty::IndexValueType> mitk::TemporoSpatialStringProperty::GetAvailableSlices(
   const TimeStepType &timeStep) const
 {
   std::vector<IndexValueType> result;
 
   auto timeIter = m_Values.find(timeStep);
   auto timeEnd = m_Values.end();
 
   if (timeIter != timeEnd)
   {
     for (auto const &element : timeIter->second)
     {
       result.push_back(element.first);
     }
   }
 
   return result;
 };
 
 std::vector<mitk::TimeStepType> mitk::TemporoSpatialStringProperty::GetAvailableTimeSteps() const
 {
   std::vector<mitk::TimeStepType> result;
 
   for (auto const &element : m_Values)
   {
     result.push_back(element.first);
   }
 
   return result;
 };
 
 std::vector<mitk::TimeStepType> mitk::TemporoSpatialStringProperty::GetAvailableTimeSteps(const IndexValueType& slice) const
 {
   std::vector<mitk::TimeStepType> result;
 
   for (const auto& timeStep : m_Values)
   {
     if (timeStep.second.find(slice) != std::end(timeStep.second))
     {
       result.push_back(timeStep.first);
     }
   }
   return result;
 }
 
 
 void mitk::TemporoSpatialStringProperty::SetValue(const TimeStepType &timeStep,
                                                   const IndexValueType &zSlice,
                                                   const ValueType &value)
 {
   auto timeIter = m_Values.find(timeStep);
   auto timeEnd = m_Values.end();
 
   if (timeIter == timeEnd)
   {
     SliceMapType slices{{zSlice, value}};
     m_Values.insert(std::make_pair(timeStep, slices));
   }
   else
   {
     timeIter->second[zSlice] = value;
   }
   this->Modified();
 };
 
 void mitk::TemporoSpatialStringProperty::SetValue(const ValueType &value)
 {
   this->Modified();
   m_Values.clear();
   this->SetValue(0, 0, value);
 };
 
 // Create necessary escape sequences from illegal characters
 // REMARK: This code is based upon code from boost::ptree::json_writer.
 // The corresponding boost function was not used directly, because it is not part of
 // the public interface of ptree::json_writer. :(
 // A own serialization strategy was implemented instead of using boost::ptree::json_write because
 // currently (<= boost 1.60) everything (even numbers) are converted into string representations
 // by the writer, so e.g. it becomes "t":"2" instaed of "t":2
 template <class Ch>
 std::basic_string<Ch> CreateJSONEscapes(const std::basic_string<Ch> &s)
 {
   std::basic_string<Ch> result;
   typename std::basic_string<Ch>::const_iterator b = s.begin();
   typename std::basic_string<Ch>::const_iterator e = s.end();
   while (b != e)
   {
-    typedef typename boost::make_unsigned<Ch>::type UCh;
+    using UCh = std::make_unsigned_t<Ch>;
     UCh c(*b);
     // This assumes an ASCII superset.
     // We escape everything outside ASCII, because this code can't
     // handle high unicode characters.
     if (c == 0x20 || c == 0x21 || (c >= 0x23 && c <= 0x2E) || (c >= 0x30 && c <= 0x5B) || (c >= 0x5D && c <= 0x7F))
       result += *b;
     else if (*b == Ch('\b'))
       result += Ch('\\'), result += Ch('b');
     else if (*b == Ch('\f'))
       result += Ch('\\'), result += Ch('f');
     else if (*b == Ch('\n'))
       result += Ch('\\'), result += Ch('n');
     else if (*b == Ch('\r'))
       result += Ch('\\'), result += Ch('r');
     else if (*b == Ch('\t'))
       result += Ch('\\'), result += Ch('t');
     else if (*b == Ch('/'))
       result += Ch('\\'), result += Ch('/');
     else if (*b == Ch('"'))
       result += Ch('\\'), result += Ch('"');
     else if (*b == Ch('\\'))
       result += Ch('\\'), result += Ch('\\');
     else
     {
       const char *hexdigits = "0123456789ABCDEF";
       unsigned long u = (std::min)(static_cast<unsigned long>(static_cast<UCh>(*b)), 0xFFFFul);
       int d1 = u / 4096;
       u -= d1 * 4096;
       int d2 = u / 256;
       u -= d2 * 256;
       int d3 = u / 16;
       u -= d3 * 16;
       int d4 = u;
       result += Ch('\\');
       result += Ch('u');
       result += Ch(hexdigits[d1]);
       result += Ch(hexdigits[d2]);
       result += Ch(hexdigits[d3]);
       result += Ch(hexdigits[d4]);
     }
     ++b;
   }
   return result;
 }
 
 using CondensedTimeKeyType = std::pair<mitk::TimeStepType, mitk::TimeStepType>;
 using CondensedTimePointsType = std::map<CondensedTimeKeyType, std::string>;
 
 using CondensedSliceKeyType = std::pair<mitk::TemporoSpatialStringProperty::IndexValueType, mitk::TemporoSpatialStringProperty::IndexValueType>;
 using CondensedSlicesType = std::map<CondensedSliceKeyType, CondensedTimePointsType>;
 
 /** Helper function that checks if between an ID and a successing ID is no gap.*/
 template<typename TValue>
 bool isGap(const TValue& value, const TValue& successor)
 {
   return value<successor || value > successor + 1;
 }
 
 
 template<typename TNewKey, typename TNewValue, typename TMasterKey, typename TMasterValue, typename TCondensedContainer>
 void CheckAndCondenseElement(const TNewKey& newKeyMinID, const TNewValue& newValue, TMasterKey& masterKey, TMasterValue& masterValue, TCondensedContainer& condensedContainer)
 {
   if (newValue != masterValue
     || isGap(newKeyMinID, masterKey.second))
   {
     condensedContainer[masterKey] = masterValue;
     masterValue = newValue;
     masterKey.first = newKeyMinID;
   }
   masterKey.second = newKeyMinID;
 }
 
 /** Helper function that tries to condense the values of time points for a slice as much as possible and returns all slices with condensed timepoint values.*/
 CondensedSlicesType CondenseTimePointValuesOfProperty(const mitk::TemporoSpatialStringProperty* tsProp)
 {
   CondensedSlicesType uncondensedSlices;
 
   auto zs = tsProp->GetAvailableSlices();
   for (const auto z : zs)
   {
     CondensedTimePointsType condensedTimePoints;
     auto timePointIDs = tsProp->GetAvailableTimeSteps(z);
     CondensedTimeKeyType condensedKey = { timePointIDs.front(),timePointIDs.front() };
     auto refValue = tsProp->GetValue(timePointIDs.front(), z);
 
     for (const auto timePointID : timePointIDs)
     {
       const auto& newVal = tsProp->GetValue(timePointID, z);
       CheckAndCondenseElement(timePointID, newVal, condensedKey, refValue, condensedTimePoints);
     }
     condensedTimePoints[condensedKey] = refValue;
     uncondensedSlices[{ z, z }] = condensedTimePoints;
   }
   return uncondensedSlices;
 }
 
 ::std::string mitk::PropertyPersistenceSerialization::serializeTemporoSpatialStringPropertyToJSON(
   const mitk::BaseProperty *prop)
 {
   // REMARK: Implemented own serialization instead of using boost::ptree::json_write because
   // currently (<= boost 1.60) everything (even numbers) are converted into string representations
   // by the writer, so e.g. it becomes "t":"2" instaed of "t":2
   // If this problem is fixed with boost, we shoud switch back to json_writer (and remove the custom
   // implementation of CreateJSONEscapes (see above)).
   const auto *tsProp = dynamic_cast<const mitk::TemporoSpatialStringProperty *>(prop);
 
   if (!tsProp)
   {
     mitkThrow() << "Cannot serialize properties of types other than TemporoSpatialStringProperty.";
   }
 
   std::ostringstream stream;
   stream.imbue(std::locale("C"));
   stream << "{\"values\":[";
 
   //we condense the content of the property to have a compact serialization.
   //we start with condensing time points and then slices (in difference to the
   //internal layout). Reason: There is more entropy in slices (looking at DICOM)
   //than across time points for one slice, so we can "compress" to a higher rate.
   //We don't wanted to change the internal structure of the property as it would
   //introduce API inconvinience and subtle changes in behavior.
   CondensedSlicesType uncondensedSlices = CondenseTimePointValuesOfProperty(tsProp);
 
   //now condense the slices
   CondensedSlicesType condensedSlices;
   if(!uncondensedSlices.empty())
   {
     CondensedTimePointsType& masterSlice = uncondensedSlices.begin()->second;
     CondensedSliceKeyType masterSliceKey = uncondensedSlices.begin()->first;
 
     for (const auto& uncondensedSlice : uncondensedSlices)
     {
       const auto& uncondensedSliceID = uncondensedSlice.first.first;
       CheckAndCondenseElement(uncondensedSliceID, uncondensedSlice.second, masterSliceKey, masterSlice, condensedSlices);
     }
     condensedSlices[masterSliceKey] = masterSlice;
   }
 
 
   bool first = true;
   for (const auto& z : condensedSlices)
   {
     for (const auto& t : z.second)
     {
       if (first)
       {
         first = false;
       }
       else
       {
         stream << ", ";
       }
 
       const auto& minSliceID = z.first.first;
       const auto& maxSliceID = z.first.second;
       const auto& minTimePointID = t.first.first;
       const auto& maxTimePointID = t.first.second;
 
       stream << "{\"z\":" << minSliceID << ", ";
       if (minSliceID != maxSliceID)
       {
         stream << "\"zmax\":" << maxSliceID << ", ";
       }
       stream << "\"t\":" << minTimePointID << ", ";
       if (minTimePointID != maxTimePointID)
       {
         stream << "\"tmax\":" << maxTimePointID << ", ";
       }
 
       const auto& value = t.second;
       stream << "\"value\":\"" << CreateJSONEscapes(value) << "\"}";
     }
   }
 
   stream << "]}";
 
   return stream.str();
 }
 
 mitk::BaseProperty::Pointer mitk::PropertyPersistenceDeserialization::deserializeJSONToTemporoSpatialStringProperty(
   const std::string &value)
 {
   if (value.empty())
     return nullptr;
 
   mitk::TemporoSpatialStringProperty::Pointer prop = mitk::TemporoSpatialStringProperty::New();
 
-  boost::property_tree::ptree root;
-
-  std::istringstream stream(value);
-  stream.imbue(std::locale("C"));
-
-  boost::property_tree::read_json(stream, root);
+  auto root = json::parse(value);
 
-  for (boost::property_tree::ptree::value_type &element : root.get_child("values"))
+  for (const auto& element : root["values"])
   {
-    std::string value = element.second.get("value", "");
-    mitk::TemporoSpatialStringProperty::IndexValueType z =
-      element.second.get<mitk::TemporoSpatialStringProperty::IndexValueType>("z", 0);
-    mitk::TemporoSpatialStringProperty::IndexValueType zmax =
-      element.second.get<mitk::TemporoSpatialStringProperty::IndexValueType>("zmax", z);
-    TimeStepType t = element.second.get<TimeStepType>("t", 0);
-    TimeStepType tmax = element.second.get<TimeStepType>("tmax", t);
+    auto value = element.value("value", "");
+    auto z = element.value<TemporoSpatialStringProperty::IndexValueType>("z", 0);
+    auto zmax = element.value<TemporoSpatialStringProperty::IndexValueType>("zmax", z);
+    auto t = element.value<TimeStepType>("t", 0);
+    auto tmax = element.value<TimeStepType>("tmax", t);
 
     for (auto currentT = t; currentT <= tmax; ++currentT)
     {
       for (auto currentZ = z; currentZ <= zmax; ++currentZ)
       {
         prop->SetValue(currentT, currentZ, value);
       }
     }
   }
 
   return prop.GetPointer();
 }
diff --git a/Modules/Core/src/IO/mitkUtf8Util.cpp b/Modules/Core/src/IO/mitkUtf8Util.cpp
index ee1604f144..023abeb147 100644
--- a/Modules/Core/src/IO/mitkUtf8Util.cpp
+++ b/Modules/Core/src/IO/mitkUtf8Util.cpp
@@ -1,87 +1,91 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkUtf8Util.h>
 #include <mitkExceptionMacro.h>
 
 #include <usGlobalConfig.h>
 
 #ifdef US_PLATFORM_WINDOWS
 
 #include <Windows.h>
 
 namespace
 {
   std::wstring MultiByteToWideChar(const std::string& mbString, UINT codePage)
   {
     auto numChars = ::MultiByteToWideChar(codePage, 0, mbString.data(), mbString.size(), nullptr, 0);
 
     if (0 >= numChars)
       mitkThrow() << "Failure to convert multi-byte character string to wide character string";
 
     std::wstring wString;
     wString.resize(numChars);
 
     ::MultiByteToWideChar(codePage, 0, mbString.data(), mbString.size(), &wString[0], static_cast<int>(wString.size()));
 
     return wString;
   }
 
   std::string WideCharToMultiByte(const std::wstring& wString, UINT codePage)
   {
     auto numChars = ::WideCharToMultiByte(codePage, 0, wString.data(), wString.size(), nullptr, 0, nullptr, nullptr);
 
     if (0 >= numChars)
       mitkThrow() << "Failure to convert wide character string to multi-byte character string";
 
     std::string mbString;
     mbString.resize(numChars);
 
     ::WideCharToMultiByte(codePage, 0, wString.data(), wString.size(), &mbString[0], static_cast<int>(mbString.size()), nullptr, nullptr);
 
     return mbString;
   }
 }
 
 #endif
 
 std::string mitk::Utf8Util::Local8BitToUtf8(const std::string& local8BitStr)
 {
 #ifdef US_PLATFORM_WINDOWS
   try
   {
-    return WideCharToMultiByte(MultiByteToWideChar(local8BitStr, CP_ACP), CP_UTF8);
+    return CP_UTF8 != GetOEMCP()
+      ? WideCharToMultiByte(MultiByteToWideChar(local8BitStr, CP_ACP), CP_UTF8)
+      : local8BitStr;
   }
   catch (const mitk::Exception&)
   {
     MITK_WARN << "String conversion from current code page to UTF-8 failed. Input string is returned unmodified.";
   }
 #endif
 
   return local8BitStr;
 }
 
 std::string mitk::Utf8Util::Utf8ToLocal8Bit(const std::string& utf8Str)
 {
 #ifdef US_PLATFORM_WINDOWS
   try
   {
-    return WideCharToMultiByte(MultiByteToWideChar(utf8Str, CP_UTF8), CP_ACP);
+    return CP_UTF8 != GetOEMCP()
+      ? WideCharToMultiByte(MultiByteToWideChar(utf8Str, CP_UTF8), CP_ACP)
+      : utf8Str;
   }
   catch (const mitk::Exception&)
   {
     MITK_WARN << "String conversion from UTF-8 to current code page failed. Input string is returned unmodified.";
   }
 #endif
 
   return utf8Str;
 }
diff --git a/Modules/Core/src/Interactions/mitkDataInteractor.cpp b/Modules/Core/src/Interactions/mitkDataInteractor.cpp
index e80023d1db..ab72645a42 100644
--- a/Modules/Core/src/Interactions/mitkDataInteractor.cpp
+++ b/Modules/Core/src/Interactions/mitkDataInteractor.cpp
@@ -1,105 +1,111 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkDataInteractor.h"
 #include "mitkDataNode.h"
 #include "mitkStateMachineState.h"
 
 namespace mitk
 {
   itkEventMacroDefinition(DataInteractorEvent, itk::AnyEvent);
   itkEventMacroDefinition(StartInteraction, DataInteractorEvent);
   itkEventMacroDefinition(ResultReady, DataInteractorEvent);
 }
 
 // Predefined internal events/signals
 const std::string mitk::DataInteractor::IntDeactivateMe = "DeactivateMe";
 const std::string mitk::DataInteractor::IntLeaveWidget = "LeaveWidget";
 const std::string mitk::DataInteractor::IntEnterWidget = "EnterWidget";
 
 mitk::DataInteractor::DataInteractor()
 {
 }
 
 mitk::DataInteractor::~DataInteractor()
 {
-  if (!m_DataNode.IsExpired())
-  {
-    auto dataNode = m_DataNode.Lock();
+  auto dataNode = m_DataNode.Lock();
 
+  if (dataNode.IsNotNull())
+  {
     if (dataNode->GetDataInteractor() == this)
       dataNode->SetDataInteractor(nullptr);
   }
 }
 
 mitk::DataNode *mitk::DataInteractor::GetDataNode() const
 {
   return m_DataNode.Lock();
 }
 
 void mitk::DataInteractor::SetDataNode(DataNode *dataNode)
 {
   if (dataNode == m_DataNode)
     return;
 
-  if (!m_DataNode.IsExpired())
-    m_DataNode.Lock()->SetDataInteractor(nullptr);
+  auto lockedDataNode = m_DataNode.Lock();
+
+  if (lockedDataNode.IsNotNull())
+    lockedDataNode->SetDataInteractor(nullptr);
 
   m_DataNode = dataNode;
 
-  if (dataNode != nullptr)
-    m_DataNode.Lock()->SetDataInteractor(this);
+  lockedDataNode = m_DataNode.Lock();
+
+  if (lockedDataNode.IsNotNull())
+    lockedDataNode->SetDataInteractor(this);
 
   this->DataNodeChanged();
 }
 
 int mitk::DataInteractor::GetLayer() const
 {
   int layer = -1;
 
-  if (!m_DataNode.IsExpired())
-    m_DataNode.Lock()->GetIntProperty("layer", layer);
+  auto dataNode = m_DataNode.Lock();
+
+  if (dataNode.IsNotNull())
+    dataNode->GetIntProperty("layer", layer);
 
   return layer;
 }
 
 void mitk::DataInteractor::ConnectActionsAndFunctions()
 {
   MITK_WARN << "DataInteractor::ConnectActionsAndFunctions() is not implemented.";
 }
 
 mitk::ProcessEventMode mitk::DataInteractor::GetMode() const
 {
   auto mode = this->GetCurrentState()->GetMode();
 
   if (mode == "PREFER_INPUT")
     return PREFERINPUT;
 
   if (mode == "GRAB_INPUT")
     return GRABINPUT;
 
   return REGULAR;
 }
 
 void mitk::DataInteractor::NotifyStart()
 {
   this->GetDataNode()->InvokeEvent(StartInteraction());
 }
 
 void mitk::DataInteractor::NotifyResultReady()
 {
   this->GetDataNode()->InvokeEvent(ResultReady());
 }
 
 void mitk::DataInteractor::DataNodeChanged()
 {
 }
diff --git a/Modules/Core/src/Interactions/mitkDispatcher.cpp b/Modules/Core/src/Interactions/mitkDispatcher.cpp
index 246bbbcf57..8072e61860 100644
--- a/Modules/Core/src/Interactions/mitkDispatcher.cpp
+++ b/Modules/Core/src/Interactions/mitkDispatcher.cpp
@@ -1,280 +1,289 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkDispatcher.h"
 #include "mitkInteractionEvent.h"
 #include "mitkInteractionEventObserver.h"
 #include "mitkInternalEvent.h"
 #include "usGetModuleContext.h"
 
 namespace
 {
   struct cmp
   {
     bool operator()(mitk::WeakPointer<mitk::DataInteractor> d1, mitk::WeakPointer<mitk::DataInteractor> d2)
     {
       return (d1.Lock()->GetLayer() > d2.Lock()->GetLayer());
     }
   };
 }
 
 mitk::Dispatcher::Dispatcher(const std::string &rendererName) : m_ProcessingMode(REGULAR)
 {
   // LDAP filter string to find all listeners specific for the renderer
   // corresponding to this dispatcher
   std::string specificRenderer = "(rendererName=" + rendererName + ")";
 
   // LDAP filter string to find all listeners that are not specific
   // to any renderer
   std::string anyRenderer = "(!(rendererName=*))";
 
   // LDAP filter string to find only instances of  InteractionEventObserver
   std::string classInteractionEventObserver =
     "(" + us::ServiceConstants::OBJECTCLASS() + "=" + us_service_interface_iid<InteractionEventObserver>() + ")";
 
   // Configure the LDAP filter to find all instances of InteractionEventObserver
   // that are specific to this dispatcher or unspecific to any dispatchers (real global listener)
   us::LDAPFilter filter("(&(|" + specificRenderer + anyRenderer + ")" + classInteractionEventObserver + ")");
 
   // Give the filter to the ObserverTracker
   m_EventObserverTracker = new us::ServiceTracker<InteractionEventObserver>(us::GetModuleContext(), filter);
   m_EventObserverTracker->Open();
 }
 
 void mitk::Dispatcher::AddDataInteractor(const DataNode *dataNode)
 {
   RemoveDataInteractor(dataNode);
   RemoveOrphanedInteractors();
 
   auto dataInteractor = dataNode->GetDataInteractor().GetPointer();
 
   if (dataInteractor != nullptr)
     m_Interactors.push_back(dataInteractor);
 }
 
 /*
  * Note: One DataInteractor can only have one DataNode and vice versa,
  * BUT the m_Interactors list may contain another DataInteractor that is still connected to this DataNode,
  * in this case we have to remove >1 DataInteractor. (Some special case of switching DataNodes between DataInteractors
  * and registering a
  * DataNode to a DataStorage after assigning it to an DataInteractor)
  */
 
 void mitk::Dispatcher::RemoveDataInteractor(const DataNode *dataNode)
 {
   for (auto it = m_Interactors.begin(); it != m_Interactors.end();)
   {
-    if ((*it).IsExpired() || (*it).Lock()->GetDataNode() == nullptr || (*it).Lock()->GetDataNode() == dataNode)
+    auto interactor = it->Lock();
+    if (interactor.IsNull() || interactor->GetDataNode() == nullptr || interactor->GetDataNode() == dataNode)
     {
       it = m_Interactors.erase(it);
     }
     else
     {
       ++it;
     }
   }
 }
 
 size_t mitk::Dispatcher::GetNumberOfInteractors()
 {
   return m_Interactors.size();
 }
 
 mitk::Dispatcher::~Dispatcher()
 {
   m_EventObserverTracker->Close();
   delete m_EventObserverTracker;
 
   m_Interactors.clear();
 }
 
 bool mitk::Dispatcher::ProcessEvent(InteractionEvent *event)
 {
   InteractionEvent::Pointer p = event;
   bool eventIsHandled = false;
   /* Filter out and handle Internal Events separately */
   auto *internalEvent = dynamic_cast<InternalEvent *>(event);
   if (internalEvent != nullptr)
   {
     eventIsHandled = HandleInternalEvent(internalEvent);
     // InternalEvents that are handled are not sent to the listeners
     if (eventIsHandled)
     {
       return true;
     }
   }
+
+  auto selectedInteractor = m_SelectedInteractor.Lock();
+
   switch (m_ProcessingMode)
   {
     case CONNECTEDMOUSEACTION:
       // finished connected mouse action
       if (std::strcmp(p->GetNameOfClass(), "MouseReleaseEvent") == 0)
       {
         m_ProcessingMode = REGULAR;
 
-        if (!m_SelectedInteractor.IsExpired())
-          eventIsHandled = m_SelectedInteractor.Lock()->HandleEvent(event, m_SelectedInteractor.Lock()->GetDataNode());
+        if (selectedInteractor.IsNotNull())
+          eventIsHandled = selectedInteractor->HandleEvent(event, selectedInteractor->GetDataNode());
 
         m_SelectedInteractor = nullptr;
       }
       // give event to selected interactor
-      if (eventIsHandled == false && !m_SelectedInteractor.IsExpired())
-        eventIsHandled = m_SelectedInteractor.Lock()->HandleEvent(event, m_SelectedInteractor.Lock()->GetDataNode());
+      selectedInteractor = m_SelectedInteractor.Lock();
+
+      if (eventIsHandled == false && selectedInteractor.IsNotNull())
+        eventIsHandled = selectedInteractor->HandleEvent(event, selectedInteractor->GetDataNode());
 
       break;
 
     case GRABINPUT:
-      if (!m_SelectedInteractor.IsExpired())
+      if (selectedInteractor.IsNotNull())
       {
-        eventIsHandled = m_SelectedInteractor.Lock()->HandleEvent(event, m_SelectedInteractor.Lock()->GetDataNode());
-        SetEventProcessingMode(m_SelectedInteractor.Lock());
+        eventIsHandled = selectedInteractor->HandleEvent(event,selectedInteractor->GetDataNode());
+        SetEventProcessingMode(selectedInteractor);
       }
 
       break;
 
     case PREFERINPUT:
-      if (!m_SelectedInteractor.IsExpired() &&
-          m_SelectedInteractor.Lock()->HandleEvent(event, m_SelectedInteractor.Lock()->GetDataNode()) == true)
+      if (selectedInteractor.IsNotNull() &&
+          selectedInteractor->HandleEvent(event, selectedInteractor->GetDataNode()) == true)
       {
-        SetEventProcessingMode(m_SelectedInteractor.Lock());
+        SetEventProcessingMode(selectedInteractor);
         eventIsHandled = true;
       }
 
       break;
 
     case REGULAR:
       break;
   }
 
   // Standard behavior. Is executed in STANDARD mode  and PREFERINPUT mode, if preferred interactor rejects event.
   if (m_ProcessingMode == REGULAR || (m_ProcessingMode == PREFERINPUT && eventIsHandled == false))
   {
     if (std::strcmp(p->GetNameOfClass(), "MousePressEvent") == 0)
       RenderingManager::GetInstance()->SetRenderWindowFocus(event->GetSender()->GetRenderWindow());
     m_Interactors.sort(cmp()); // sorts interactors by layer (descending);
 
     // copy the list to prevent iterator invalidation as executing actions
     // in HandleEvent() can cause the m_Interactors list to be updated
     const ListInteractorType tmpInteractorList(m_Interactors);
     ListInteractorType::const_iterator it;
     for (it = tmpInteractorList.cbegin(); it != tmpInteractorList.cend(); ++it)
     {
-      if (!(*it).IsExpired() && (*it).Lock()->HandleEvent(event, (*it).Lock()->GetDataNode()))
+      auto interactor = it->Lock();
+      if (interactor.IsNotNull() && interactor->HandleEvent(event, interactor->GetDataNode()))
       {
         // Interactor can be deleted during HandleEvent(), so check it again
-        if (!(*it).IsExpired())
+        interactor = it->Lock();
+        if (interactor.IsNotNull())
         {
           // if an event is handled several properties are checked, in order to determine the processing mode of the
           // dispatcher
-          SetEventProcessingMode((*it).Lock());
+          SetEventProcessingMode(interactor);
         }
         if (std::strcmp(p->GetNameOfClass(), "MousePressEvent") == 0 && m_ProcessingMode == REGULAR)
         {
           m_SelectedInteractor = *it;
           m_ProcessingMode = CONNECTEDMOUSEACTION;
         }
         eventIsHandled = true;
         break;
       }
     }
   }
 
   /* Notify InteractionEventObserver  */
   const std::vector<us::ServiceReference<InteractionEventObserver>> listEventObserver =
     m_EventObserverTracker->GetServiceReferences();
   for (auto it = listEventObserver.cbegin();
        it != listEventObserver.cend();
        ++it)
   {
     InteractionEventObserver *interactionEventObserver = m_EventObserverTracker->GetService(*it);
     if (interactionEventObserver != nullptr)
     {
       if (interactionEventObserver->IsEnabled())
       {
         interactionEventObserver->Notify(event, eventIsHandled);
       }
     }
   }
 
   // Process event queue
   if (!m_QueuedEvents.empty())
   {
     InteractionEvent::Pointer e = m_QueuedEvents.front();
     m_QueuedEvents.pop_front();
     ProcessEvent(e);
   }
   return eventIsHandled;
 }
 
 /*
  * Checks if DataNodes associated with DataInteractors point back to them.
  * If not remove the DataInteractors. (This can happen when s.o. tries to set DataNodes to multiple DataInteractors)
  */
 void mitk::Dispatcher::RemoveOrphanedInteractors()
 {
   for (auto it = m_Interactors.begin(); it != m_Interactors.end();)
   {
-    if ((*it).IsExpired())
+    auto interactor = it->Lock();
+    if (interactor.IsNull())
     {
       it = m_Interactors.erase(it);
     }
     else
     {
-      DataNode::Pointer node = (*it).Lock()->GetDataNode();
+      DataNode::Pointer node = interactor->GetDataNode();
 
       if (node.IsNull())
       {
         it = m_Interactors.erase(it);
       }
       else
       {
-        DataInteractor::Pointer interactor = node->GetDataInteractor();
+        interactor = node->GetDataInteractor();
 
         if (interactor != it->Lock().GetPointer())
         {
           it = m_Interactors.erase(it);
         }
         else
         {
           ++it;
         }
       }
     }
   }
 }
 
 void mitk::Dispatcher::QueueEvent(InteractionEvent *event)
 {
   m_QueuedEvents.push_back(event);
 }
 
 void mitk::Dispatcher::SetEventProcessingMode(DataInteractor *dataInteractor)
 {
   m_ProcessingMode = dataInteractor->GetMode();
   if (dataInteractor->GetMode() != REGULAR)
   {
     m_SelectedInteractor = dataInteractor;
   }
 }
 
 bool mitk::Dispatcher::HandleInternalEvent(InternalEvent *internalEvent)
 {
   if (internalEvent->GetSignalName() == DataInteractor::IntDeactivateMe &&
       internalEvent->GetTargetInteractor() != nullptr)
   {
     internalEvent->GetTargetInteractor()->GetDataNode()->SetDataInteractor(nullptr);
     internalEvent->GetTargetInteractor()->SetDataNode(nullptr);
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     return true;
   }
   return false;
 }
diff --git a/Modules/Core/src/Interactions/mitkDisplayActionEventHandler.cpp b/Modules/Core/src/Interactions/mitkDisplayActionEventHandler.cpp
index c4c14dc242..fb8d38945f 100644
--- a/Modules/Core/src/Interactions/mitkDisplayActionEventHandler.cpp
+++ b/Modules/Core/src/Interactions/mitkDisplayActionEventHandler.cpp
@@ -1,105 +1,108 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkDisplayActionEventHandler.h"
 
 mitk::DisplayActionEventHandler::~DisplayActionEventHandler()
 {
-  if (!m_ObservableBroadcast.IsExpired())
-  {
-    auto observableBroadcastPtr = m_ObservableBroadcast.Lock();
+  auto observableBroadcastPtr = m_ObservableBroadcast.Lock();
 
+  if (observableBroadcastPtr.IsNotNull())
+  {
     // remove current observer
     for (const auto& tag : m_ObserverTags)
     {
       observableBroadcastPtr->RemoveObserver(tag);
     }
     m_ObserverTags.clear();
   }
 }
 
 void mitk::DisplayActionEventHandler::SetObservableBroadcast(DisplayActionEventBroadcast* observableBroadcast)
 {
   if (m_ObservableBroadcast == observableBroadcast)
   {
     // no need to update the broadcast class
     return;
   }
 
-  if (!m_ObservableBroadcast.IsExpired())
-  {
-    auto observableBroadcastPtr = m_ObservableBroadcast.Lock();
+  auto observableBroadcastPtr = m_ObservableBroadcast.Lock();
 
+  if (observableBroadcastPtr.IsNotNull())
+  {
     // remove current observer
     for (const auto& tag : m_ObserverTags)
     {
       observableBroadcastPtr->RemoveObserver(tag);
     }
     m_ObserverTags.clear();
   }
 
   // set new broadcast class
   m_ObservableBroadcast = observableBroadcast;
 }
 
 mitk::DisplayActionEventHandler::OberserverTagType mitk::DisplayActionEventHandler::ConnectDisplayActionEvent(const DisplayActionEvent& displayActionEvent,
   const StdFunctionCommand::ActionFunction& actionFunction,
   const StdFunctionCommand::FilterFunction& filterFunction)
 {
-  if (m_ObservableBroadcast.IsExpired())
+  auto observableBroadcast = m_ObservableBroadcast.Lock();
+
+  if (observableBroadcast.IsNull())
   {
     mitkThrow() << "No display action event broadcast class set to observe. Use 'SetObservableBroadcast' before connecting events.";
   }
 
-  auto observableBroadcast = m_ObservableBroadcast.Lock();
   auto command = StdFunctionCommand::New();
   command->SetCommandAction(actionFunction);
   command->SetCommandFilter(filterFunction);
   OberserverTagType tag = observableBroadcast->AddObserver(displayActionEvent, command);
   m_ObserverTags.push_back(tag);
   return tag;
 }
 
 void mitk::DisplayActionEventHandler::DisconnectObserver(OberserverTagType observerTag)
 {
-  if (m_ObservableBroadcast.IsExpired())
+  auto observableBroadcast = m_ObservableBroadcast.Lock();
+
+  if (observableBroadcast.IsNull())
   {
     mitkThrow() << "No display action event broadcast class set to observe. Use 'SetObservableBroadcast' before disconnecting observer.";
   }
 
-  auto observableBroadcast = m_ObservableBroadcast.Lock();
   std::vector<OberserverTagType>::iterator observerTagPosition = std::find(m_ObserverTags.begin(), m_ObserverTags.end(), observerTag);
   if (observerTagPosition != m_ObserverTags.end())
   {
     observableBroadcast->RemoveObserver(observerTag);
     m_ObserverTags.erase(observerTagPosition);
   }
 }
 
 void mitk::DisplayActionEventHandler::InitActions()
 {
-  if (m_ObservableBroadcast.IsExpired())
+  auto observableBroadcast = m_ObservableBroadcast.Lock();
+
+  if (observableBroadcast.IsNull())
   {
     mitkThrow() << "No display action event broadcast class set to observe. Use 'SetObservableBroadcast' before initializing actions.";
   }
 
-  auto observableBroadcast = m_ObservableBroadcast.Lock();
   // remove all current display action events as observer
   auto allObserverTags = GetAllObserverTags();
   for (const auto& tag : allObserverTags)
   {
     observableBroadcast->RemoveObserver(tag);
   }
   m_ObserverTags.clear();
 
   InitActionsImpl();
 }
diff --git a/Modules/Core/src/Rendering/mitkImageVtkMapper2D.cpp b/Modules/Core/src/Rendering/mitkImageVtkMapper2D.cpp
index 12555a0d66..c4af3d3340 100644
--- a/Modules/Core/src/Rendering/mitkImageVtkMapper2D.cpp
+++ b/Modules/Core/src/Rendering/mitkImageVtkMapper2D.cpp
@@ -1,1153 +1,1153 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // MITK
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkDataNode.h>
 #include <mitkImageSliceSelector.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkPixelType.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkProperties.h>
 #include <mitkPropertyNameHelper.h>
 #include <mitkResliceMethodProperty.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 
 //#include <mitkTransferFunction.h>
 #include "mitkImageStatisticsHolder.h"
 #include "mitkPlaneClipping.h"
 #include <mitkTransferFunctionProperty.h>
 
 // MITK Rendering
 #include "mitkImageVtkMapper2D.h"
 #include "vtkMitkLevelWindowFilter.h"
 #include "vtkMitkThickSlicesFilter.h"
 #include "vtkNeverTranslucentTexture.h"
 
 // VTK
 #include <vtkCamera.h>
 #include <vtkCellArray.h>
 #include <vtkColorTransferFunction.h>
 #include <vtkGeneralTransform.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkImageData.h>
 #include <vtkImageExtractComponents.h>
 #include <vtkImageReslice.h>
 #include <vtkLookupTable.h>
 #include <vtkMatrix4x4.h>
 #include <vtkPlaneSource.h>
 #include <vtkPoints.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
 #include <vtkTransform.h>
 
 // ITK
 #include <itkRGBAPixel.h>
 #include <mitkRenderingModeProperty.h>
 
 namespace
 {
   bool IsBinaryImage(mitk::Image* image)
   {
     if (nullptr != image && image->IsInitialized())
     {
       bool isBinary = true;
       auto statistics = image->GetStatistics();
 
       const auto numTimeSteps = image->GetTimeSteps();
 
       for (std::remove_const_t<decltype(numTimeSteps)> t = 0; t < numTimeSteps; ++t)
       {
         const auto numChannels = image->GetNumberOfChannels();
 
         for (std::remove_const_t<decltype(numChannels)> c = 0; c < numChannels; ++c)
         {
           auto minValue = statistics->GetScalarValueMin(t, c);
           auto maxValue = statistics->GetScalarValueMax(t, c);
 
           if (std::abs(maxValue - minValue) < mitk::eps)
             continue;
 
           auto min2ndValue = statistics->GetScalarValue2ndMin(t, c);
           auto max2ndValue = statistics->GetScalarValue2ndMax(t, c);
 
           if (std::abs(maxValue - min2ndValue) < mitk::eps && std::abs(max2ndValue - minValue) < mitk::eps)
             continue;
 
           isBinary = false;
           break;
         }
 
         if (!isBinary)
           break;
       }
 
       return isBinary;
     }
 
     return false;
   }
 }
 
 mitk::ImageVtkMapper2D::ImageVtkMapper2D()
 {
 }
 
 mitk::ImageVtkMapper2D::~ImageVtkMapper2D()
 {
   // The 3D RW Mapper (PlaneGeometryDataVtkMapper3D) is listening to this event,
   // in order to delete the images from the 3D RW.
   this->InvokeEvent(itk::DeleteEvent());
 }
 
 // set the two points defining the textured plane according to the dimension and spacing
 void mitk::ImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer *renderer, double planeBounds[6])
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   float depth = this->CalculateLayerDepth(renderer);
   // Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
   // plane size in crosshair rotation and swivel mode.
   localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
   // These two points define the axes of the plane in combination with the origin.
   // Point 1 is the x-axis and point 2 the y-axis.
-  // Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
+  // Each plane is transformed according to the view (axial, coronal and sagittal) afterwards.
   localStorage->m_Plane->SetPoint1(planeBounds[1], planeBounds[2], depth); // P1: (xMax, yMin, depth)
   localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); // P2: (xMin, yMax, depth)
 }
 
 float mitk::ImageVtkMapper2D::CalculateLayerDepth(mitk::BaseRenderer *renderer)
 {
   // get the clipping range to check how deep into z direction we can render images
   double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
 
   // Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
   float depth = -maxRange * 0.01; // divide by 100
   int layer = 0;
   GetDataNode()->GetIntProperty("layer", layer, renderer);
   // add the layer property for each image to render images with a higher layer on top of the others
   depth += layer * 10; //*10: keep some room for each image (e.g. for ODFs in between)
   if (depth > 0.0f)
   {
     depth = 0.0f;
     MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
   }
   return depth;
 }
 
 const mitk::Image *mitk::ImageVtkMapper2D::GetInput(void)
 {
   return static_cast<const mitk::Image *>(GetDataNode()->GetData());
 }
 
 vtkProp *mitk::ImageVtkMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   // return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_PublicActors;
 }
 
 void mitk::ImageVtkMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   auto *image = const_cast<mitk::Image *>(this->GetInput());
   mitk::DataNode *datanode = this->GetDataNode();
   if (nullptr == image || !image->IsInitialized())
   {
     this->SetToInvalidState(localStorage);
     return;
   }
 
   // check if there is a valid worldGeometry
   const PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
   if (nullptr == worldGeometry || !worldGeometry->IsValid() || !worldGeometry->HasReferenceGeometry())
   {
     this->SetToInvalidState(localStorage);
     return;
   }
 
   image->Update();
 
   localStorage->m_PublicActors = localStorage->m_Actors.Get();
 
   // early out if there is no intersection of the current rendering geometry
   // and the geometry of the image that is to be rendered.
   if (!RenderingGeometryIntersectsImage(worldGeometry, image->GetSlicedGeometry()))
   {
     this->SetToInvalidState(localStorage);
     return;
   }
 
   // set main input for ExtractSliceFilter
   localStorage->m_Reslicer->SetInput(image);
   localStorage->m_Reslicer->SetWorldGeometry(worldGeometry);
   localStorage->m_Reslicer->SetTimeStep(this->GetTimestep());
 
   // set the transformation of the image to adapt reslice axis
   localStorage->m_Reslicer->SetResliceTransformByGeometry(
     image->GetTimeGeometry()->GetGeometryForTimeStep(this->GetTimestep()));
 
   // is the geometry of the slice based on the input image or the worldgeometry?
   bool inPlaneResampleExtentByGeometry = false;
   datanode->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
   localStorage->m_Reslicer->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
 
   // Initialize the interpolation mode for resampling; switch to nearest
   // neighbor if the input image is too small.
   if ((image->GetDimension() >= 3) && (image->GetDimension(2) > 1))
   {
     VtkResliceInterpolationProperty *resliceInterpolationProperty;
     datanode->GetProperty(resliceInterpolationProperty, "reslice interpolation", renderer);
 
     int interpolationMode = VTK_RESLICE_NEAREST;
     if (resliceInterpolationProperty != nullptr)
     {
       interpolationMode = resliceInterpolationProperty->GetInterpolation();
     }
 
     switch (interpolationMode)
     {
       case VTK_RESLICE_NEAREST:
         localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
         break;
       case VTK_RESLICE_LINEAR:
         localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_LINEAR);
         break;
       case VTK_RESLICE_CUBIC:
         localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_CUBIC);
         break;
     }
   }
   else
   {
     localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
   }
 
   // set the vtk output property to true, makes sure that no unneeded mitk image convertion
   // is done.
   localStorage->m_Reslicer->SetVtkOutputRequest(true);
 
   // Thickslicing
   int thickSlicesMode = 0;
   int thickSlicesNum = 1;
   // Thick slices parameters
   if (image->GetPixelType().GetNumberOfComponents() == 1) // for now only single component are allowed
   {
     DataNode *dn = renderer->GetCurrentWorldPlaneGeometryNode();
     if (dn)
     {
       ResliceMethodProperty *resliceMethodEnumProperty = nullptr;
 
       if (dn->GetProperty(resliceMethodEnumProperty, "reslice.thickslices", renderer) && resliceMethodEnumProperty)
         thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
 
       IntProperty *intProperty = nullptr;
       if (dn->GetProperty(intProperty, "reslice.thickslices.num", renderer) && intProperty)
       {
         thickSlicesNum = intProperty->GetValue();
         if (thickSlicesNum < 1)
           thickSlicesNum = 1;
       }
     }
     else
     {
       MITK_WARN << "no associated widget plane data tree node found";
     }
   }
 
   const auto *planeGeometry = dynamic_cast<const PlaneGeometry *>(worldGeometry);
 
   if (thickSlicesMode > 0)
   {
     double dataZSpacing = 1.0;
 
     Vector3D normInIndex, normal;
 
     const auto *abstractGeometry =
       dynamic_cast<const AbstractTransformGeometry *>(worldGeometry);
     if (abstractGeometry != nullptr)
       normal = abstractGeometry->GetPlane()->GetNormal();
     else
     {
       if (planeGeometry != nullptr)
       {
         normal = planeGeometry->GetNormal();
       }
       else
         return; // no fitting geometry set
     }
     normal.Normalize();
 
     image->GetTimeGeometry()->GetGeometryForTimeStep(this->GetTimestep())->WorldToIndex(normal, normInIndex);
 
     dataZSpacing = 1.0 / normInIndex.GetNorm();
 
     localStorage->m_Reslicer->SetOutputDimensionality(3);
     localStorage->m_Reslicer->SetOutputSpacingZDirection(dataZSpacing);
     localStorage->m_Reslicer->SetOutputExtentZDirection(-thickSlicesNum, 0 + thickSlicesNum);
 
     // Do the reslicing. Modified() is called to make sure that the reslicer is
     // executed even though the input geometry information did not change; this
     // is necessary when the input /em data, but not the /em geometry changes.
     localStorage->m_TSFilter->SetThickSliceMode(thickSlicesMode - 1);
     localStorage->m_TSFilter->SetInputData(localStorage->m_Reslicer->GetVtkOutput());
 
     // vtkFilter=>mitkFilter=>vtkFilter update mechanism will fail without calling manually
     localStorage->m_Reslicer->Modified();
     localStorage->m_Reslicer->Update();
 
     localStorage->m_TSFilter->Modified();
     localStorage->m_TSFilter->Update();
     localStorage->m_ReslicedImage = localStorage->m_TSFilter->GetOutput();
   }
   else
   {
     // this is needed when thick mode was enable bevore. These variable have to be reset to default values
     localStorage->m_Reslicer->SetOutputDimensionality(2);
     localStorage->m_Reslicer->SetOutputSpacingZDirection(1.0);
     localStorage->m_Reslicer->SetOutputExtentZDirection(0, 0);
 
     localStorage->m_Reslicer->Modified();
     // start the pipeline with updating the largest possible, needed if the geometry of the input has changed
     localStorage->m_Reslicer->UpdateLargestPossibleRegion();
     localStorage->m_ReslicedImage = localStorage->m_Reslicer->GetVtkOutput();
   }
 
   // Bounds information for reslicing (only reuqired if reference geometry
   // is present)
   // this used for generating a vtkPLaneSource with the right size
   double sliceBounds[6];
   for (auto &sliceBound : sliceBounds)
   {
     sliceBound = 0.0;
   }
   localStorage->m_Reslicer->GetClippedPlaneBounds(sliceBounds);
 
   // get the spacing of the slice
   localStorage->m_mmPerPixel = localStorage->m_Reslicer->GetOutputSpacing();
 
   // calculate minimum bounding rect of IMAGE in texture
   {
     double textureClippingBounds[6];
     for (auto &textureClippingBound : textureClippingBounds)
     {
       textureClippingBound = 0.0;
     }
     // Calculate the actual bounds of the transformed plane clipped by the
     // dataset bounding box; this is required for drawing the texture at the
     // correct position during 3D mapping.
     mitk::PlaneClipping::CalculateClippedPlaneBounds(image->GetGeometry(), planeGeometry, textureClippingBounds);
 
     textureClippingBounds[0] = static_cast<int>(textureClippingBounds[0] / localStorage->m_mmPerPixel[0] + 0.5);
     textureClippingBounds[1] = static_cast<int>(textureClippingBounds[1] / localStorage->m_mmPerPixel[0] + 0.5);
     textureClippingBounds[2] = static_cast<int>(textureClippingBounds[2] / localStorage->m_mmPerPixel[1] + 0.5);
     textureClippingBounds[3] = static_cast<int>(textureClippingBounds[3] / localStorage->m_mmPerPixel[1] + 0.5);
 
     // clipping bounds for cutting the image
     localStorage->m_LevelWindowFilter->SetClippingBounds(textureClippingBounds);
   }
 
   // get the number of scalar components to distinguish between different image types
   int numberOfComponents = localStorage->m_ReslicedImage->GetNumberOfScalarComponents();
   // get the binary property
   bool binary = false;
   bool binaryOutline = false;
   datanode->GetBoolProperty("binary", binary, renderer);
   if (binary) // binary image
   {
     datanode->GetBoolProperty("outline binary", binaryOutline, renderer);
     if (binaryOutline) // contour rendering
     {
       // get pixel type of vtk image
       auto componentType = image->GetPixelType().GetComponentType();
       switch (componentType)
       {
       case itk::IOComponentEnum::UCHAR:
         // generate contours/outlines
         localStorage->m_OutlinePolyData = CreateOutlinePolyData<unsigned char>(renderer);
         break;
       case itk::IOComponentEnum::USHORT:
         // generate contours/outlines
         localStorage->m_OutlinePolyData = CreateOutlinePolyData<unsigned short>(renderer);
         break;
       default:
         binaryOutline = false;
         this->ApplyLookuptable(renderer);
         MITK_WARN << "Type of all binary images should be unsigned char or unsigned short. Outline does not work on other pixel types!";
       }
       if (binaryOutline) // binary outline is still true --> add outline
       {
         float binaryOutlineWidth = 1.0;
         if (datanode->GetFloatProperty("outline width", binaryOutlineWidth, renderer))
         {
           float binaryOutlineShadowWidth = 1.5;
           datanode->GetFloatProperty("outline shadow width", binaryOutlineShadowWidth, renderer);
           localStorage->m_ShadowOutlineActor->GetProperty()->SetLineWidth(binaryOutlineWidth * binaryOutlineShadowWidth);
 
           localStorage->m_ImageActor->GetProperty()->SetLineWidth(binaryOutlineWidth);
         }
       }
     }
     else // standard binary image
     {
       if (numberOfComponents != 1)
       {
         MITK_ERROR << "Rendering Error: Binary Images with more then 1 component are not supported!";
       }
     }
   }
 
   this->ApplyOpacity(renderer);
   this->ApplyRenderingMode(renderer);
 
   // do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
   localStorage->m_Texture->SetColorModeToDirectScalars();
 
   int displayedComponent = 0;
 
   if (datanode->GetIntProperty("Image.Displayed Component", displayedComponent, renderer) && numberOfComponents > 1)
   {
     localStorage->m_VectorComponentExtractor->SetComponents(displayedComponent);
     localStorage->m_VectorComponentExtractor->SetInputData(localStorage->m_ReslicedImage);
 
     localStorage->m_LevelWindowFilter->SetInputConnection(localStorage->m_VectorComponentExtractor->GetOutputPort(0));
   }
   else
   {
     // connect the input with the levelwindow filter
     localStorage->m_LevelWindowFilter->SetInputData(localStorage->m_ReslicedImage);
   }
 
   // check for texture interpolation property
   bool textureInterpolation = false;
   GetDataNode()->GetBoolProperty("texture interpolation", textureInterpolation, renderer);
 
   // set the interpolation modus according to the property
   localStorage->m_Texture->SetInterpolate(textureInterpolation);
 
   // connect the texture with the output of the levelwindow filter
   localStorage->m_Texture->SetInputConnection(localStorage->m_LevelWindowFilter->GetOutputPort());
 
   this->TransformActor(renderer);
 
   if (binary && binaryOutline) // connect the mapper with the polyData which contains the lines
   {
     // We need the contour for the binary outline property as actor
     localStorage->m_Mapper->SetInputData(localStorage->m_OutlinePolyData);
     localStorage->m_ImageActor->SetTexture(nullptr); // no texture for contours
 
     bool binaryOutlineShadow = false;
     datanode->GetBoolProperty("outline binary shadow", binaryOutlineShadow, renderer);
     if (binaryOutlineShadow)
     {
       localStorage->m_ShadowOutlineActor->SetVisibility(true);
     }
     else
     {
       localStorage->m_ShadowOutlineActor->SetVisibility(false);
     }
   }
   else
   { // Connect the mapper with the input texture. This is the standard case.
     // setup the textured plane
     this->GeneratePlane(renderer, sliceBounds);
     // set the plane as input for the mapper
     localStorage->m_Mapper->SetInputConnection(localStorage->m_Plane->GetOutputPort());
     // set the texture for the actor
     localStorage->m_ImageActor->SetTexture(localStorage->m_Texture);
     localStorage->m_ShadowOutlineActor->SetVisibility(false);
   }
 
   // We have been modified => save this for next Update()
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::ImageVtkMapper2D::ApplyLevelWindow(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
 
   LevelWindow levelWindow;
   this->GetDataNode()->GetLevelWindow(levelWindow, renderer, "levelwindow");
   localStorage->m_LevelWindowFilter->GetLookupTable()->SetRange(levelWindow.GetLowerWindowBound(),
                                                                 levelWindow.GetUpperWindowBound());
 
   mitk::LevelWindow opacLevelWindow;
   if (this->GetDataNode()->GetLevelWindow(opacLevelWindow, renderer, "opaclevelwindow"))
   {
     // pass the opaque level window to the filter
     localStorage->m_LevelWindowFilter->SetMinOpacity(opacLevelWindow.GetLowerWindowBound());
     localStorage->m_LevelWindowFilter->SetMaxOpacity(opacLevelWindow.GetUpperWindowBound());
   }
   else
   {
     // no opaque level window
     localStorage->m_LevelWindowFilter->SetMinOpacity(0.0);
     localStorage->m_LevelWindowFilter->SetMaxOpacity(255.0);
   }
 }
 
 void mitk::ImageVtkMapper2D::ApplyColor(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
 
   float rgb[3] = {1.0f, 1.0f, 1.0f};
 
   // check for color prop and use it for rendering if it exists
   // binary image hovering & binary image selection
   bool hover = false;
   bool selected = false;
   bool binary = false;
   GetDataNode()->GetBoolProperty("binaryimage.ishovering", hover, renderer);
   GetDataNode()->GetBoolProperty("selected", selected, renderer);
   GetDataNode()->GetBoolProperty("binary", binary, renderer);
   if (binary && hover && !selected)
   {
     mitk::ColorProperty::Pointer colorprop =
       dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("binaryimage.hoveringcolor", renderer));
     if (colorprop.IsNotNull())
     {
       memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float));
     }
     else
     {
       GetDataNode()->GetColor(rgb, renderer, "color");
     }
   }
   if (binary && selected)
   {
     mitk::ColorProperty::Pointer colorprop =
       dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("binaryimage.selectedcolor", renderer));
     if (colorprop.IsNotNull())
     {
       memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float));
     }
     else
     {
       GetDataNode()->GetColor(rgb, renderer, "color");
     }
   }
   if (!binary || (!hover && !selected))
   {
     GetDataNode()->GetColor(rgb, renderer, "color");
   }
 
   double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; // conversion to double for VTK
   localStorage->m_ShadowOutlineActor->GetProperty()->SetColor(rgbConv);
   localStorage->m_ImageActor->GetProperty()->SetColor(rgbConv);
 
   float shadowRGB[3] = {1.0f, 1.0f, 1.0f};
   mitk::ColorProperty::Pointer colorprop =
     dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("outline binary shadow color", renderer));
   if (colorprop.IsNotNull())
   {
     memcpy(shadowRGB, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float));
   }
   double shadowRGBConv[3] = {(double)shadowRGB[0], (double)shadowRGB[1], (double)shadowRGB[2]}; // conversion to double for VTK
   localStorage->m_ShadowOutlineActor->GetProperty()->SetColor(shadowRGBConv);
 }
 
 void mitk::ImageVtkMapper2D::ApplyOpacity(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
   float opacity = 1.0f;
   // check for opacity prop and use it for rendering if it exists
   GetDataNode()->GetOpacity(opacity, renderer, "opacity");
   // set the opacity according to the properties
   localStorage->m_ImageActor->GetProperty()->SetOpacity(opacity);
   localStorage->m_ShadowOutlineActor->GetProperty()->SetOpacity(opacity);
 }
 
 void mitk::ImageVtkMapper2D::ApplyRenderingMode(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   bool binary = false;
   this->GetDataNode()->GetBoolProperty("binary", binary, renderer);
   if (binary) // is it a binary image?
   {
     // for binary images, we always use our default LuT and map every value to (0,1)
     // the opacity of 0 will always be 0.0. We never a apply a LuT/TfF nor a level window.
     localStorage->m_LevelWindowFilter->SetLookupTable(localStorage->m_BinaryLookupTable);
   }
   else
   {
     // all other image types can make use of the rendering mode
     int renderingMode = mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR;
     mitk::RenderingModeProperty::Pointer mode =
       dynamic_cast<mitk::RenderingModeProperty *>(this->GetDataNode()->GetProperty("Image Rendering.Mode", renderer));
     if (mode.IsNotNull())
     {
       renderingMode = mode->GetRenderingMode();
     }
     switch (renderingMode)
     {
       case mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR:
         MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_LookupTable_Color";
         this->ApplyLookuptable(renderer);
         this->ApplyLevelWindow(renderer);
         break;
       case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR:
         MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_ColorTransferFunction_Color";
         this->ApplyColorTransferFunction(renderer);
         this->ApplyLevelWindow(renderer);
         break;
       case mitk::RenderingModeProperty::LOOKUPTABLE_COLOR:
         MITK_DEBUG << "'Image Rendering.Mode' = LookupTable_Color";
         this->ApplyLookuptable(renderer);
         break;
       case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR:
         MITK_DEBUG << "'Image Rendering.Mode' = ColorTransferFunction_Color";
         this->ApplyColorTransferFunction(renderer);
         break;
       default:
         MITK_ERROR << "No valid 'Image Rendering.Mode' set. Using LOOKUPTABLE_LEVELWINDOW_COLOR instead.";
         this->ApplyLookuptable(renderer);
         this->ApplyLevelWindow(renderer);
         break;
     }
   }
   // we apply color for all images (including binaries).
   this->ApplyColor(renderer);
 }
 
 void mitk::ImageVtkMapper2D::ApplyLookuptable(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   vtkLookupTable *usedLookupTable = localStorage->m_ColorLookupTable;
 
   // If lookup table or transferfunction use is requested...
   mitk::LookupTableProperty::Pointer lookupTableProp =
     dynamic_cast<mitk::LookupTableProperty *>(this->GetDataNode()->GetProperty("LookupTable", renderer));
 
   if (lookupTableProp.IsNotNull()) // is a lookuptable set?
   {
     usedLookupTable = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
   }
   else
   {
     //"Image Rendering.Mode was set to use a lookup table but there is no property 'LookupTable'.
     // A default (rainbow) lookup table will be used.
     // Here have to do nothing. Warning for the user has been removed, due to unwanted console output
     // in every interation of the rendering.
   }
   localStorage->m_LevelWindowFilter->SetLookupTable(usedLookupTable);
 }
 
 void mitk::ImageVtkMapper2D::ApplyColorTransferFunction(mitk::BaseRenderer *renderer)
 {
   mitk::TransferFunctionProperty::Pointer transferFunctionProp = dynamic_cast<mitk::TransferFunctionProperty *>(
     this->GetDataNode()->GetProperty("Image Rendering.Transfer Function", renderer));
 
   if (transferFunctionProp.IsNull())
   {
     MITK_ERROR << "'Image Rendering.Mode'' was set to use a color transfer function but there is no property 'Image "
                   "Rendering.Transfer Function'. Nothing will be done.";
     return;
   }
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   // pass the transfer function to our level window filter
   localStorage->m_LevelWindowFilter->SetLookupTable(transferFunctionProp->GetValue()->GetColorTransferFunction());
   localStorage->m_LevelWindowFilter->SetOpacityPiecewiseFunction(
     transferFunctionProp->GetValue()->GetScalarOpacityFunction());
 }
 
 void mitk::ImageVtkMapper2D::SetToInvalidState(mitk::ImageVtkMapper2D::LocalStorage* localStorage)
 {
   localStorage->m_PublicActors = localStorage->m_EmptyActors.Get();
   // set image to nullptr, to clear the texture in 3D, because
   // the latest image is used there if the plane is out of the geometry
   // see bug-13275
   localStorage->m_ReslicedImage = nullptr;
   localStorage->m_Mapper->SetInputData(localStorage->m_EmptyPolyData);
 }
 
 void mitk::ImageVtkMapper2D::Update(mitk::BaseRenderer *renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if (!visible)
   {
     return;
   }
 
   auto *data = const_cast<mitk::Image *>(this->GetInput());
   if (data == nullptr)
   {
     return;
   }
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep(renderer);
 
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
 
   // Check if time step is valid
   const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ((dataTimeGeometry == nullptr) || (dataTimeGeometry->CountTimeSteps() == 0) ||
       (!dataTimeGeometry->IsValidTimeStep(this->GetTimestep())))
   {
     this->SetToInvalidState(localStorage);
     return;
   }
 
   const DataNode *node = this->GetDataNode();
   data->UpdateOutputInformation();
 
   // check if something important has changed and we need to rerender
   if ((localStorage->m_LastUpdateTime < node->GetMTime()) ||
       (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) ||
       (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) ||
       (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()) ||
       (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) ||
       (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) ||
       (localStorage->m_LastUpdateTime < data->GetPropertyList()->GetMTime()))
   {
     this->GenerateDataForRenderer(renderer);
   }
 
   // since we have checked that nothing important has changed, we can set
   // m_LastUpdateTime to the current time
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::ImageVtkMapper2D::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite)
 {
   mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
 
   // Properties common for both images and segmentations
   node->AddProperty("depthOffset", mitk::FloatProperty::New(0.0), renderer, overwrite);
   node->AddProperty("outline binary", mitk::BoolProperty::New(false), renderer, overwrite);
   node->AddProperty("outline width", mitk::FloatProperty::New(1.0), renderer, overwrite);
   node->AddProperty("outline binary shadow", mitk::BoolProperty::New(false), renderer, overwrite);
   node->AddProperty("outline binary shadow color", ColorProperty::New(0.0, 0.0, 0.0), renderer, overwrite);
   node->AddProperty("outline shadow width", mitk::FloatProperty::New(1.5), renderer, overwrite);
   if (image->IsRotated())
     node->AddProperty("reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_CUBIC));
   else
     node->AddProperty("reslice interpolation", mitk::VtkResliceInterpolationProperty::New());
   node->AddProperty("texture interpolation", mitk::BoolProperty::New(false));
   node->AddProperty("in plane resample extent by geometry", mitk::BoolProperty::New(false));
   node->AddProperty("bounding box", mitk::BoolProperty::New(false));
 
   mitk::RenderingModeProperty::Pointer renderingModeProperty = mitk::RenderingModeProperty::New();
   node->AddProperty("Image Rendering.Mode", renderingModeProperty);
 
   // Set default grayscale look-up table
   mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
   mitkLut->SetType(mitk::LookupTable::GRAYSCALE);
   mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
   mitkLutProp->SetLookupTable(mitkLut);
   node->SetProperty("LookupTable", mitkLutProp, renderer);
 
   std::string photometricInterpretation; // DICOM tag telling us how pixel values should be displayed
   if (node->GetStringProperty("dicom.pixel.PhotometricInterpretation", photometricInterpretation))
   {
     // modality provided by DICOM or other reader
     if (photometricInterpretation.find("MONOCHROME1") != std::string::npos) // meaning: display MINIMUM pixels as WHITE
     {
       // Set inverse grayscale look-up table
       mitkLut->SetType(mitk::LookupTable::INVERSE_GRAYSCALE);
       mitkLutProp->SetLookupTable(mitkLut);
       node->SetProperty("LookupTable", mitkLutProp, renderer);
       renderingModeProperty->SetValue(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR); // USE lookuptable
     }
     // Otherwise do nothing - the default grayscale look-up table has already been set
   }
 
   bool isBinaryImage(false);
   if (!node->GetBoolProperty("binary", isBinaryImage) && image->GetPixelType().GetNumberOfComponents() == 1)
   {
     // ok, property is not set, use heuristic to determine if this
     // is a binary image
     mitk::Image::Pointer centralSliceImage;
     mitk::ImageSliceSelector::Pointer sliceSelector = mitk::ImageSliceSelector::New();
 
     sliceSelector->SetInput(image);
     sliceSelector->SetSliceNr(image->GetDimension(2) / 2);
     sliceSelector->SetTimeNr(image->GetDimension(3) / 2);
     sliceSelector->SetChannelNr(image->GetDimension(4) / 2);
     sliceSelector->Update();
     centralSliceImage = sliceSelector->GetOutput();
 
     isBinaryImage = IsBinaryImage(centralSliceImage);
 
     if (isBinaryImage) // Potential binary image. Now take a close look.
       isBinaryImage = IsBinaryImage(image);
   }
 
   std::string className = image->GetNameOfClass();
   if (className != "TensorImage" && className != "OdfImage" && className != "ShImage")
   {
     PixelType pixelType = image->GetPixelType();
     size_t numComponents = pixelType.GetNumberOfComponents();
 
     if ((pixelType.GetPixelType() == itk::IOPixelEnum::VECTOR && numComponents > 1) || numComponents == 2 ||
         numComponents > 4)
     {
       node->AddProperty("Image.Displayed Component", mitk::IntProperty::New(0), renderer, overwrite);
     }
   }
 
   // some more properties specific for a binary...
   if (isBinaryImage)
   {
     node->AddProperty("opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite);
     node->AddProperty("color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
     node->AddProperty("binaryimage.selectedcolor", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
     node->AddProperty("binaryimage.selectedannotationcolor", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
     node->AddProperty("binaryimage.hoveringcolor", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
     node->AddProperty("binaryimage.hoveringannotationcolor", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
     node->AddProperty("binary", mitk::BoolProperty::New(true), renderer, overwrite);
     node->AddProperty("layer", mitk::IntProperty::New(10), renderer, overwrite);
   }
   else //...or image type object
   {
     node->AddProperty("opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite);
     node->AddProperty("color", ColorProperty::New(1.0, 1.0, 1.0), renderer, overwrite);
     node->AddProperty("binary", mitk::BoolProperty::New(false), renderer, overwrite);
     node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
   }
 
   if (image.IsNotNull() && image->IsInitialized())
   {
     if ((overwrite) || (node->GetProperty("levelwindow", renderer) == nullptr))
     {
       /* initialize level/window from DICOM tags */
       mitk::LevelWindow contrast;
 
       std::string sLevel = "";
       std::string sWindow = "";
       if (GetBackwardsCompatibleDICOMProperty(
             0x0028, 0x1050, "dicom.voilut.WindowCenter", image->GetPropertyList(), sLevel) &&
           GetBackwardsCompatibleDICOMProperty(
             0x0028, 0x1051, "dicom.voilut.WindowWidth", image->GetPropertyList(), sWindow))
       {
         float level = atof(sLevel.c_str());
         float window = atof(sWindow.c_str());
 
         std::string sSmallestPixelValueInSeries;
         std::string sLargestPixelValueInSeries;
 
         if (GetBackwardsCompatibleDICOMProperty(0x0028,
                                                 0x0108,
                                                 "dicom.series.SmallestPixelValueInSeries",
                                                 image->GetPropertyList(),
                                                 sSmallestPixelValueInSeries) &&
             GetBackwardsCompatibleDICOMProperty(0x0028,
                                                 0x0109,
                                                 "dicom.series.LargestPixelValueInSeries",
                                                 image->GetPropertyList(),
                                                 sLargestPixelValueInSeries))
         {
           float smallestPixelValueInSeries = atof(sSmallestPixelValueInSeries.c_str());
           float largestPixelValueInSeries = atof(sLargestPixelValueInSeries.c_str());
           contrast.SetRangeMinMax(smallestPixelValueInSeries - 1,
                                   largestPixelValueInSeries + 1); // why not a little buffer?
           // might remedy some l/w widget challenges
         }
         else
         {
           contrast.SetAuto(static_cast<mitk::Image *>(node->GetData()), false, true); // fallback
         }
         contrast.SetLevelWindow(level, window, true);
       }
       else
       {
         contrast.SetAuto(static_cast<mitk::Image *>(node->GetData()), false, true); // fallback
       }
 
       node->SetProperty("levelwindow", LevelWindowProperty::New(contrast), renderer);
     }
 
     if (((overwrite) || (node->GetProperty("opaclevelwindow", renderer) == nullptr)) &&
         (image->GetPixelType().GetPixelType() == itk::IOPixelEnum::RGBA) &&
         (image->GetPixelType().GetComponentType() == itk::IOComponentEnum::UCHAR))
     {
       mitk::LevelWindow opaclevwin;
       opaclevwin.SetRangeMinMax(0, 255);
       opaclevwin.SetWindowBounds(0, 255);
       mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin);
       node->SetProperty("opaclevelwindow", prop, renderer);
     }
   }
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 mitk::ImageVtkMapper2D::LocalStorage *mitk::ImageVtkMapper2D::GetLocalStorage(mitk::BaseRenderer *renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 const mitk::ImageVtkMapper2D::LocalStorage* mitk::ImageVtkMapper2D::GetConstLocalStorage(mitk::BaseRenderer* renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 template <typename TPixel>
 vtkSmartPointer<vtkPolyData> mitk::ImageVtkMapper2D::CreateOutlinePolyData(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
 
   // get the min and max index values of each direction
   int *extent = localStorage->m_ReslicedImage->GetExtent();
   int xMin = extent[0];
   int xMax = extent[1];
   int yMin = extent[2];
   int yMax = extent[3];
 
   int *dims = localStorage->m_ReslicedImage->GetDimensions(); // dimensions of the image
   int line = dims[0];                                         // how many pixels per line?
   int x = xMin;                                               // pixel index x
   int y = yMin;                                               // pixel index y
 
   // get the depth for each contour
   float depth = CalculateLayerDepth(renderer);
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();      // the points to draw
   vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New(); // the lines to connect the points
 
   // We take the pointer to the first pixel of the image
   auto* currentPixel = static_cast<TPixel*>(localStorage->m_ReslicedImage->GetScalarPointer());
 
   while (y <= yMax)
   {
     // if the current pixel value is set to something
     if ((currentPixel) && (*currentPixel != 0))
     {
       // check in which direction a line is necessary
       // a line is added if the neighbor of the current pixel has the value 0
       // and if the pixel is located at the edge of the image
 
       // if   vvvvv  not the first line vvvvv
       if (y > yMin && *(currentPixel - line) == 0)
       { // x direction - bottom edge of the pixel
         // add the 2 points
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         // add the line between both points
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  not the last line vvvvv
       if (y < yMax && *(currentPixel + line) == 0)
       { // x direction - top edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  not the first pixel vvvvv
       if ((x > xMin || y > yMin) && *(currentPixel - 1) == 0)
       { // y direction - left edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  not the last pixel vvvvv
       if ((y < yMax || (x < xMax)) && *(currentPixel + 1) == 0)
       { // y direction - right edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       /*  now consider pixels at the edge of the image  */
 
       // if   vvvvv  left edge of image vvvvv
       if (x == xMin)
       { // draw left edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  right edge of image vvvvv
       if (x == xMax)
       { // draw right edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  bottom edge of image vvvvv
       if (y == yMin)
       { // draw bottom edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  top edge of image vvvvv
       if (y == yMax)
       { // draw top edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
     } // end if currentpixel is set
 
     x++;
 
     if (x > xMax)
     { // reached end of line
       x = xMin;
       y++;
     }
 
     // Increase the pointer-position to the next pixel.
     // This is safe, as the while-loop and the x-reset logic above makes
     // sure we do not exceed the bounds of the image
     currentPixel++;
   } // end of while
 
   // Create a polydata to store everything in
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   // Add the points to the dataset
   polyData->SetPoints(points);
   // Add the lines to the dataset
   polyData->SetLines(lines);
   return polyData;
 }
 
 void mitk::ImageVtkMapper2D::TransformActor(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
-  // get the transformation matrix of the reslicer in order to render the slice as axial, coronal or saggital
+  // get the transformation matrix of the reslicer in order to render the slice as axial, coronal or sagittal
   vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
   vtkSmartPointer<vtkMatrix4x4> matrix = localStorage->m_Reslicer->GetResliceAxes();
   trans->SetMatrix(matrix);
-  // transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or saggital)
+  // transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or sagittal)
   localStorage->m_ImageActor->SetUserTransform(trans);
   // transform the origin to center based coordinates, because MITK is center based.
   localStorage->m_ImageActor->SetPosition(-0.5 * localStorage->m_mmPerPixel[0], -0.5 * localStorage->m_mmPerPixel[1], 0.0);
 
   localStorage->m_ShadowOutlineActor->SetUserTransform(trans);
   localStorage->m_ShadowOutlineActor->SetPosition(-0.5 * localStorage->m_mmPerPixel[0], -0.5 * localStorage->m_mmPerPixel[1], 0.0);
 }
 
 bool mitk::ImageVtkMapper2D::RenderingGeometryIntersectsImage(const PlaneGeometry *renderingGeometry,
                                                               SlicedGeometry3D *imageGeometry)
 {
   // if either one of the two geometries is nullptr we return true
   // for safety reasons
   if (renderingGeometry == nullptr || imageGeometry == nullptr)
     return true;
 
   // get the distance for the first cornerpoint
   ScalarType initialDistance = renderingGeometry->SignedDistance(imageGeometry->GetCornerPoint(0));
   for (int i = 1; i < 8; i++)
   {
     mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint(i);
 
     // get the distance to the other cornerpoints
     ScalarType distance = renderingGeometry->SignedDistance(cornerPoint);
 
     // if it has not the same signing as the distance of the first point
     if (initialDistance * distance < 0)
     {
       // we have an intersection and return true
       return true;
     }
   }
 
   // all distances have the same sign, no intersection and we return false
   return false;
 }
 
 mitk::ImageVtkMapper2D::LocalStorage::~LocalStorage()
 {
 }
 
 mitk::ImageVtkMapper2D::LocalStorage::LocalStorage()
   : m_VectorComponentExtractor(vtkSmartPointer<vtkImageExtractComponents>::New())
 {
   m_LevelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
 
   // Do as much actions as possible in here to avoid double executions.
   m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
   m_Texture = vtkSmartPointer<vtkNeverTranslucentTexture>::New().GetPointer();
   m_DefaultLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_BinaryLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_ColorLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_ImageActor = vtkSmartPointer<vtkActor>::New();
   m_ShadowOutlineActor = vtkSmartPointer<vtkActor>::New();
   m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
   m_EmptyActors = vtkSmartPointer<vtkPropAssembly>::New();
   m_Reslicer = mitk::ExtractSliceFilter::New();
   m_TSFilter = vtkSmartPointer<vtkMitkThickSlicesFilter>::New();
   m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
   m_ReslicedImage = vtkSmartPointer<vtkImageData>::New();
   m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
 
   // the following actions are always the same and thus can be performed
   // in the constructor for each image (i.e. the image-corresponding local storage)
   m_TSFilter->ReleaseDataFlagOn();
 
   mitk::LookupTable::Pointer mitkLUT = mitk::LookupTable::New();
   // built a default lookuptable
   mitkLUT->SetType(mitk::LookupTable::GRAYSCALE);
   m_DefaultLookupTable = mitkLUT->GetVtkLookupTable();
 
   mitkLUT->SetType(mitk::LookupTable::LEGACY_BINARY);
   m_BinaryLookupTable = mitkLUT->GetVtkLookupTable();
 
   mitkLUT->SetType(mitk::LookupTable::LEGACY_RAINBOW_COLOR);
   m_ColorLookupTable = mitkLUT->GetVtkLookupTable();
 
   // do not repeat the texture (the image)
   m_Texture->RepeatOff();
 
   // set the mapper for the actor
   m_ImageActor->SetMapper(m_Mapper);
   m_ShadowOutlineActor->SetMapper(m_Mapper);
 
   m_Actors->AddPart(m_ShadowOutlineActor);
   m_Actors->AddPart(m_ImageActor);
 
   m_PublicActors = m_EmptyActors.Get();
 }
diff --git a/Modules/Core/src/Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp b/Modules/Core/src/Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
index c49b3d3cc5..3a4b4ff08d 100644
--- a/Modules/Core/src/Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
+++ b/Modules/Core/src/Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
@@ -1,584 +1,585 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkPlaneGeometryDataVtkMapper3D.h"
 
 #include "mitkImageVtkMapper2D.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateOr.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkSurface.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkWeakPointerProperty.h"
 #include "vtkMitkLevelWindowFilter.h"
 #include "vtkNeverTranslucentTexture.h"
 
 #include <vtkAssembly.h>
 #include <vtkDataSetMapper.h>
 #include <vtkFeatureEdges.h>
 #include <vtkHedgeHog.h>
 #include <vtkImageData.h>
 #include <vtkLinearTransform.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProp3DCollection.h>
 #include <vtkProperty.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkTubeFilter.h>
 
 namespace mitk
 {
   PlaneGeometryDataVtkMapper3D::PlaneGeometryDataVtkMapper3D() : m_NormalsActorAdded(false), m_DataStorage(nullptr)
   {
     m_EdgeTuber = vtkTubeFilter::New();
     m_EdgeMapper = vtkPolyDataMapper::New();
 
     m_SurfaceCreator = PlaneGeometryDataToSurfaceFilter::New();
     m_SurfaceCreatorBoundingBox = BoundingBox::New();
     m_SurfaceCreatorPointsContainer = BoundingBox::PointsContainer::New();
     m_Edges = vtkFeatureEdges::New();
 
     m_Edges->BoundaryEdgesOn();
     m_Edges->FeatureEdgesOff();
     m_Edges->NonManifoldEdgesOff();
     m_Edges->ManifoldEdgesOff();
 
     m_EdgeTransformer = vtkTransformPolyDataFilter::New();
     m_NormalsTransformer = vtkTransformPolyDataFilter::New();
     m_EdgeActor = vtkActor::New();
     m_BackgroundMapper = vtkPolyDataMapper::New();
     m_BackgroundActor = vtkActor::New();
     m_Prop3DAssembly = vtkAssembly::New();
     m_ImageAssembly = vtkAssembly::New();
 
     m_SurfaceCreatorBoundingBox->SetPoints(m_SurfaceCreatorPointsContainer);
 
     m_Cleaner = vtkCleanPolyData::New();
 
     m_Cleaner->PieceInvariantOn();
     m_Cleaner->ConvertLinesToPointsOn();
     m_Cleaner->ConvertPolysToLinesOn();
     m_Cleaner->ConvertStripsToPolysOn();
     m_Cleaner->PointMergingOn();
 
     // Make sure that the FeatureEdge algorithm is initialized with a "valid"
     // (though empty) input
     vtkPolyData *emptyPolyData = vtkPolyData::New();
     m_Cleaner->SetInputData(emptyPolyData);
     emptyPolyData->Delete();
 
     m_Edges->SetInputConnection(m_Cleaner->GetOutputPort());
     m_EdgeTransformer->SetInputConnection(m_Edges->GetOutputPort());
 
     m_EdgeTuber->SetInputConnection(m_EdgeTransformer->GetOutputPort());
     m_EdgeTuber->SetVaryRadiusToVaryRadiusOff();
     m_EdgeTuber->SetNumberOfSides(12);
     m_EdgeTuber->CappingOn();
 
     m_EdgeMapper->SetInputConnection(m_EdgeTuber->GetOutputPort());
     m_EdgeMapper->ScalarVisibilityOff();
 
     m_BackgroundMapper->SetInputData(emptyPolyData);
     m_BackgroundMapper->Update();
 
     m_EdgeActor->SetMapper(m_EdgeMapper);
 
     m_BackgroundActor->GetProperty()->SetAmbient(0.5);
     m_BackgroundActor->GetProperty()->SetColor(0.0, 0.0, 0.0);
     m_BackgroundActor->GetProperty()->SetOpacity(0.0);
     m_BackgroundActor->SetMapper(m_BackgroundMapper);
 
     vtkProperty *backfaceProperty = m_BackgroundActor->MakeProperty();
     backfaceProperty->SetColor(0.0, 0.0, 0.0);
     m_BackgroundActor->SetBackfaceProperty(backfaceProperty);
     backfaceProperty->Delete();
 
     m_FrontHedgeHog = vtkHedgeHog::New();
     m_BackHedgeHog = vtkHedgeHog::New();
 
     m_FrontNormalsMapper = vtkPolyDataMapper::New();
     m_FrontNormalsMapper->SetInputConnection(m_FrontHedgeHog->GetOutputPort());
     m_BackNormalsMapper = vtkPolyDataMapper::New();
 
     m_Prop3DAssembly->AddPart(m_EdgeActor);
     m_Prop3DAssembly->AddPart(m_ImageAssembly);
     m_FrontNormalsActor = vtkActor::New();
     m_FrontNormalsActor->SetMapper(m_FrontNormalsMapper);
     m_BackNormalsActor = vtkActor::New();
     m_BackNormalsActor->SetMapper(m_BackNormalsMapper);
 
     m_ImageMapperDeletedCommand = MemberCommandType::New();
     m_ImageMapperDeletedCommand->SetCallbackFunction(this, &PlaneGeometryDataVtkMapper3D::ImageMapperDeletedCallback);
   }
 
   PlaneGeometryDataVtkMapper3D::~PlaneGeometryDataVtkMapper3D()
   {
     m_ImageAssembly->Delete();
     m_Prop3DAssembly->Delete();
     m_EdgeTuber->Delete();
     m_EdgeMapper->Delete();
     m_EdgeTransformer->Delete();
     m_Cleaner->Delete();
     m_Edges->Delete();
     m_NormalsTransformer->Delete();
     m_EdgeActor->Delete();
     m_BackgroundMapper->Delete();
     m_BackgroundActor->Delete();
     m_FrontNormalsMapper->Delete();
     m_FrontNormalsActor->Delete();
     m_FrontHedgeHog->Delete();
     m_BackNormalsMapper->Delete();
     m_BackNormalsActor->Delete();
     m_BackHedgeHog->Delete();
 
     for (auto it = m_ImageActors.begin(); it != m_ImageActors.end(); ++it)
       it->second.m_Actor->ReleaseGraphicsResources(nullptr);
 
     // Delete entries in m_ImageActors list one by one
     m_ImageActors.clear();
 
     m_DataStorage = nullptr;
   }
 
   vtkProp *PlaneGeometryDataVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
   {
     if ((this->GetDataNode() != nullptr) && (m_ImageAssembly != nullptr))
     {
       // Do not transform the entire Prop3D assembly, but only the image part
       // here. The colored frame is transformed elsewhere (via m_EdgeTransformer),
       // since only vertices should be transformed there, not the poly data
       // itself, to avoid distortion for anisotropic datasets.
       m_ImageAssembly->SetUserTransform(this->GetDataNode()->GetVtkTransform());
     }
     return m_Prop3DAssembly;
   }
 
   void PlaneGeometryDataVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
   {
     m_ImageAssembly->SetUserTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()));
   }
 
   const PlaneGeometryData *PlaneGeometryDataVtkMapper3D::GetInput()
   {
     return static_cast<const PlaneGeometryData *>(GetDataNode()->GetData());
   }
 
   void PlaneGeometryDataVtkMapper3D::SetDataStorageForTexture(mitk::DataStorage *storage)
   {
     if (storage != nullptr && m_DataStorage != storage)
     {
       m_DataStorage = storage;
       this->Modified();
     }
   }
 
   void PlaneGeometryDataVtkMapper3D::ImageMapperDeletedCallback(itk::Object *caller, const itk::EventObject & /*event*/)
   {
     auto *imageMapper = dynamic_cast<ImageVtkMapper2D *>(caller);
     if ((imageMapper != nullptr))
     {
       if (m_ImageActors.count(imageMapper) > 0)
       {
         m_ImageActors[imageMapper].m_Sender = nullptr; // sender is already destroying itself
         m_ImageActors.erase(imageMapper);
       }
     }
   }
 
   void PlaneGeometryDataVtkMapper3D::GenerateDataForRenderer(BaseRenderer *renderer)
   {
     // Remove all actors from the assembly, and re-initialize it with the
     // edge actor
     m_ImageAssembly->GetParts()->RemoveAllItems();
 
     bool visible = true;
     GetDataNode()->GetVisibility(visible, renderer, "visible");
 
     if (!visible)
     {
       // visibility has explicitly to be set in the single actors
       // due to problems when using cell picking:
       // even if the assembly is invisible, the renderer contains
       // references to the assemblies parts. During picking the
       // visibility of each part is checked, and not only for the
       // whole assembly.
       m_ImageAssembly->VisibilityOff();
       m_EdgeActor->VisibilityOff();
       return;
     }
 
     // visibility has explicitly to be set in the single actors
     // due to problems when using cell picking:
     // even if the assembly is invisible, the renderer contains
     // references to the assemblies parts. During picking the
     // visibility of each part is checked, and not only for the
     // whole assembly.
     m_ImageAssembly->VisibilityOn();
     bool drawEdges = true;
     this->GetDataNode()->GetBoolProperty("draw edges", drawEdges, renderer);
     m_EdgeActor->SetVisibility(drawEdges);
 
     PlaneGeometryData::ConstPointer input = this->GetInput();
 
     if (input.IsNotNull() && (input->GetPlaneGeometry() != nullptr))
     {
       SmartPointerProperty::Pointer surfacecreatorprop;
       surfacecreatorprop =
         dynamic_cast<SmartPointerProperty *>(GetDataNode()->GetProperty("surfacegeometry", renderer));
 
       if ((surfacecreatorprop.IsNull()) || (surfacecreatorprop->GetSmartPointer().IsNull()) ||
           ((m_SurfaceCreator =
               dynamic_cast<PlaneGeometryDataToSurfaceFilter *>(surfacecreatorprop->GetSmartPointer().GetPointer()))
              .IsNull()))
       {
         m_SurfaceCreator->PlaceByGeometryOn();
         surfacecreatorprop = SmartPointerProperty::New(m_SurfaceCreator);
         GetDataNode()->SetProperty("surfacegeometry", surfacecreatorprop);
       }
 
       m_SurfaceCreator->SetInput(input);
 
       int res;
       if (GetDataNode()->GetIntProperty("xresolution", res, renderer))
       {
         m_SurfaceCreator->SetXResolution(res);
       }
       if (GetDataNode()->GetIntProperty("yresolution", res, renderer))
       {
         m_SurfaceCreator->SetYResolution(res);
       }
 
       double tubeRadius = 1.0; // Radius of tubular edge surrounding plane
+      auto dataStorage = m_DataStorage.Lock();
 
       // Clip the PlaneGeometry with the reference geometry bounds (if available)
       if (input->GetPlaneGeometry()->HasReferenceGeometry())
       {
         const BaseGeometry *referenceGeometry = input->GetPlaneGeometry()->GetReferenceGeometry();
 
         BoundingBox::PointType boundingBoxMin, boundingBoxMax;
         boundingBoxMin = referenceGeometry->GetBoundingBox()->GetMinimum();
         boundingBoxMax = referenceGeometry->GetBoundingBox()->GetMaximum();
 
         if (referenceGeometry->GetImageGeometry())
         {
           for (unsigned int i = 0; i < 3; ++i)
           {
             boundingBoxMin[i] -= 0.5;
             boundingBoxMax[i] -= 0.5;
           }
         }
 
         m_SurfaceCreatorPointsContainer->CreateElementAt(0) = boundingBoxMin;
         m_SurfaceCreatorPointsContainer->CreateElementAt(1) = boundingBoxMax;
 
         m_SurfaceCreatorBoundingBox->ComputeBoundingBox();
 
         m_SurfaceCreator->SetBoundingBox(m_SurfaceCreatorBoundingBox);
 
         tubeRadius = referenceGeometry->GetDiagonalLength() / 450.0;
       }
 
       // If no reference geometry is available, clip with the current global
       // bounds
-      else if (!m_DataStorage.IsExpired())
+      else if (dataStorage.IsNotNull())
       {
-        m_SurfaceCreator->SetBoundingBox(m_DataStorage.Lock()->ComputeVisibleBoundingBox(nullptr, "includeInBoundingBox"));
+        m_SurfaceCreator->SetBoundingBox(dataStorage->ComputeVisibleBoundingBox(nullptr, "includeInBoundingBox"));
         tubeRadius = sqrt(m_SurfaceCreator->GetBoundingBox()->GetDiagonalLength2()) / 450.0;
       }
 
       // Calculate the surface of the PlaneGeometry
       m_SurfaceCreator->Update();
       Surface *surface = m_SurfaceCreator->GetOutput();
 
       // Check if there's something to display, otherwise return
       if ((surface->GetVtkPolyData() == nullptr) || (surface->GetVtkPolyData()->GetNumberOfCells() == 0))
       {
         m_ImageAssembly->VisibilityOff();
         return;
       }
 
       // add a graphical representation of the surface normals if requested
       DataNode *node = this->GetDataNode();
       bool displayNormals = false;
       bool colorTwoSides = false;
       bool invertNormals = false;
       node->GetBoolProperty("draw normals 3D", displayNormals, renderer);
       node->GetBoolProperty("color two sides", colorTwoSides, renderer);
       node->GetBoolProperty("invert normals", invertNormals, renderer);
 
       // if we want to draw the display normals or render two sides we have to get the colors
       if (displayNormals || colorTwoSides)
       {
         // get colors
         float frontColor[3] = {0.0, 0.0, 1.0};
         node->GetColor(frontColor, renderer, "front color");
         float backColor[3] = {1.0, 0.0, 0.0};
         node->GetColor(backColor, renderer, "back color");
 
         if (displayNormals)
         {
           m_NormalsTransformer->SetInputData(surface->GetVtkPolyData());
           m_NormalsTransformer->SetTransform(node->GetVtkTransform(this->GetTimestep()));
 
           m_FrontHedgeHog->SetInputConnection(m_NormalsTransformer->GetOutputPort());
           m_FrontHedgeHog->SetVectorModeToUseNormal();
           m_FrontHedgeHog->SetScaleFactor(invertNormals ? 1.0 : -1.0);
           m_FrontHedgeHog->Update();
 
           m_FrontNormalsActor->GetProperty()->SetColor(frontColor[0], frontColor[1], frontColor[2]);
 
           m_BackHedgeHog->SetInputConnection(m_NormalsTransformer->GetOutputPort());
           m_BackHedgeHog->SetVectorModeToUseNormal();
           m_BackHedgeHog->SetScaleFactor(invertNormals ? -1.0 : 1.0);
           m_BackHedgeHog->Update();
 
           m_BackNormalsActor->GetProperty()->SetColor(backColor[0], backColor[1], backColor[2]);
 
           // if there is no actor added yet, add one
           if (!m_NormalsActorAdded)
           {
             m_Prop3DAssembly->AddPart(m_FrontNormalsActor);
             m_Prop3DAssembly->AddPart(m_BackNormalsActor);
             m_NormalsActorAdded = true;
           }
         }
         // if we don't want to display normals AND there is an actor added remove the actor
         else if (m_NormalsActorAdded)
         {
           m_Prop3DAssembly->RemovePart(m_FrontNormalsActor);
           m_Prop3DAssembly->RemovePart(m_BackNormalsActor);
           m_NormalsActorAdded = false;
         }
 
         if (colorTwoSides)
         {
           if (!invertNormals)
           {
             m_BackgroundActor->GetProperty()->SetColor(backColor[0], backColor[1], backColor[2]);
             m_BackgroundActor->GetBackfaceProperty()->SetColor(frontColor[0], frontColor[1], frontColor[2]);
           }
           else
           {
             m_BackgroundActor->GetProperty()->SetColor(frontColor[0], frontColor[1], frontColor[2]);
             m_BackgroundActor->GetBackfaceProperty()->SetColor(backColor[0], backColor[1], backColor[2]);
           }
         }
       }
 
       // Add black background for all images (which may be transparent)
       m_BackgroundMapper->SetInputData(surface->GetVtkPolyData());
       //      m_ImageAssembly->AddPart(m_BackgroundActor);
 
       LayerSortedActorList layerSortedActors;
 
       // Traverse the data tree to find nodes resliced by ImageMapperGL2D
       // use a predicate to get all data nodes which are "images" or inherit from mitk::Image
       mitk::TNodePredicateDataType<mitk::Image>::Pointer predicateAllImages =
         mitk::TNodePredicateDataType<mitk::Image>::New();
       mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage.Lock()->GetSubset(predicateAllImages);
       // process all found images
       for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
       {
         DataNode *node = it->Value();
         if (node != nullptr)
           this->ProcessNode(node, renderer, surface, layerSortedActors);
       }
 
       // Add all image actors to the assembly, sorted according to
       // layer property
       LayerSortedActorList::iterator actorIt;
       for (actorIt = layerSortedActors.begin(); actorIt != layerSortedActors.end(); ++actorIt)
       {
         m_ImageAssembly->AddPart(actorIt->second);
       }
 
       // Configurate the tube-shaped frame: size according to the surface
       // bounds, color as specified in the plane's properties
       vtkPolyData *surfacePolyData = surface->GetVtkPolyData();
       m_Cleaner->SetInputData(surfacePolyData);
       m_EdgeTransformer->SetTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()));
 
       // Adjust the radius according to extent
       m_EdgeTuber->SetRadius(tubeRadius);
 
       // Get the plane's color and set the tube properties accordingly
       ColorProperty::Pointer colorProperty;
       colorProperty = dynamic_cast<ColorProperty *>(this->GetDataNode()->GetProperty("color"));
       if (colorProperty.IsNotNull())
       {
         const Color &color = colorProperty->GetColor();
         m_EdgeActor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
       }
       else
       {
         m_EdgeActor->GetProperty()->SetColor(1.0, 1.0, 1.0);
       }
 
       m_ImageAssembly->SetUserTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()));
     }
 
     VtkRepresentationProperty *representationProperty;
     this->GetDataNode()->GetProperty(representationProperty, "material.representation", renderer);
     if (representationProperty != nullptr)
       m_BackgroundActor->GetProperty()->SetRepresentation(representationProperty->GetVtkRepresentation());
   }
 
   void PlaneGeometryDataVtkMapper3D::ProcessNode(DataNode *node,
                                                  BaseRenderer *renderer,
                                                  Surface *surface,
                                                  LayerSortedActorList &layerSortedActors)
   {
     if (node != nullptr)
     {
       // we need to get the information from the 2D mapper to render the texture on the 3D plane
       auto *imageMapper =
         dynamic_cast<ImageVtkMapper2D *>(node->GetMapper(1)); // GetMapper(1) provides the 2D mapper for the data node
 
       // if there is a 2D mapper, which is not the standard image mapper...
       if (!imageMapper && node->GetMapper(1))
       { //... check if it is the composite mapper
         std::string cname(node->GetMapper(1)->GetNameOfClass());
         if (!cname.compare("CompositeMapper")) // string.compare returns 0 if the two strings are equal.
         {
           // get the standard image mapper.
           // This is a special case in MITK and does only work for the CompositeMapper.
           imageMapper = dynamic_cast<ImageVtkMapper2D *>(node->GetMapper(3));
         }
       }
 
       if ((node->IsVisible(renderer)) && imageMapper)
       {
         WeakPointerProperty::Pointer rendererProp =
           dynamic_cast<WeakPointerProperty *>(GetDataNode()->GetPropertyList()->GetProperty("renderer"));
 
         if (rendererProp.IsNotNull())
         {
           BaseRenderer::Pointer planeRenderer =
             dynamic_cast<BaseRenderer *>(rendererProp->GetWeakPointer().GetPointer());
           // Retrieve and update image to be mapped
           const ImageVtkMapper2D::LocalStorage *localStorage = imageMapper->GetConstLocalStorage(planeRenderer);
 
           if (planeRenderer.IsNotNull())
           {
             // perform update of imagemapper if needed (maybe the respective 2D renderwindow is not rendered/update
             // before)
             imageMapper->Update(planeRenderer);
 
             // If it has not been initialized already in a previous pass,
             // generate an actor and a texture object to
             // render the image associated with the ImageVtkMapper2D.
             vtkActor *imageActor;
             vtkDataSetMapper *dataSetMapper = nullptr;
             vtkTexture *texture;
             if (m_ImageActors.count(imageMapper) == 0)
             {
               dataSetMapper = vtkDataSetMapper::New();
 
               texture = vtkNeverTranslucentTexture::New();
               texture->RepeatOff();
 
               imageActor = vtkActor::New();
               imageActor->SetMapper(dataSetMapper);
               imageActor->SetTexture(texture);
               imageActor->GetProperty()->SetOpacity(
                 0.999); // HACK! otherwise VTK wouldn't recognize this as translucent
                         // surface (if LUT values map to alpha < 255
               // improvement: apply "opacity" property onle HERE and also in 2D image mapper. DO NOT change LUT to
               // achieve
               // translucent images (see method ChangeOpacity in image mapper 2D)
 
               // Make imageActor the sole owner of the mapper and texture
               // objects
               dataSetMapper->UnRegister(nullptr);
               texture->UnRegister(nullptr);
 
               // Store the actor so that it may be accessed in following
               // passes.
               m_ImageActors[imageMapper].Initialize(imageActor, imageMapper, m_ImageMapperDeletedCommand);
             }
             else
             {
               // Else, retrieve the actor and associated objects from the
               // previous pass.
               imageActor = m_ImageActors[imageMapper].m_Actor;
               dataSetMapper = (vtkDataSetMapper *)imageActor->GetMapper();
               texture = imageActor->GetTexture();
             }
 
             // Set poly data new each time its object changes (e.g. when
             // switching between planar and curved geometries)
             if ((dataSetMapper != nullptr) && (dataSetMapper->GetInput() != surface->GetVtkPolyData()))
             {
               dataSetMapper->SetInputData(surface->GetVtkPolyData());
             }
 
             dataSetMapper->Update();
 
             // Check if the m_ReslicedImage is nullptr.
             // This is the case when no image geometry is met by
             // the reslicer. In that case, the texture has to be
             // empty (black) and we don't have to do anything.
             // See fixed bug #13275
             if (localStorage->m_ReslicedImage != nullptr)
             {
               texture->SetInputConnection(localStorage->m_LevelWindowFilter->GetOutputPort());
 
               // do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
               texture->SetColorModeToDirectScalars();
 
               auto* property3d = imageActor->GetProperty();
               property3d->LightingOff();
 
               // re-use properties from the 2D image mapper
               auto* property2d = localStorage->m_ImageActor->GetProperty();
               property3d->SetColor(property2d->GetColor());
               property3d->SetOpacity(property2d->GetOpacity());
 
               // Set texture interpolation on/off
               bool textureInterpolation = node->IsOn("texture interpolation", renderer);
               texture->SetInterpolate(textureInterpolation);
 
               // Store this actor to be added to the actor assembly, sort
               // by layer
               int layer = 1;
               node->GetIntProperty("layer", layer);
               layerSortedActors.insert(std::pair<int, vtkActor *>(layer, imageActor));
             }
           }
         }
       }
     }
   }
 
   void PlaneGeometryDataVtkMapper3D::ActorInfo::Initialize(vtkActor *actor, itk::Object *sender, itk::Command *command)
   {
     m_Actor = actor;
     m_Sender = sender;
     // Get informed when ImageMapper object is deleted, so that
     // the data structures built here can be deleted as well
     m_ObserverID = sender->AddObserver(itk::DeleteEvent(), command);
   }
 
   PlaneGeometryDataVtkMapper3D::ActorInfo::ActorInfo() : m_Actor(nullptr), m_Sender(nullptr), m_ObserverID(0) {}
   PlaneGeometryDataVtkMapper3D::ActorInfo::~ActorInfo()
   {
     if (m_Sender != nullptr)
     {
       m_Sender->RemoveObserver(m_ObserverID);
     }
     if (m_Actor != nullptr)
     {
       m_Actor->ReleaseGraphicsResources(nullptr);
       m_Actor->Delete();
     }
   }
 } // namespace mitk
diff --git a/Modules/Core/test/mitkExtractSliceFilterTest.cpp b/Modules/Core/test/mitkExtractSliceFilterTest.cpp
index ce21ea7eef..6bb27c7e6b 100644
--- a/Modules/Core/test/mitkExtractSliceFilterTest.cpp
+++ b/Modules/Core/test/mitkExtractSliceFilterTest.cpp
@@ -1,1069 +1,1069 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 #include <mitkExtractSliceFilter.h>
 #include <mitkIOUtil.h>
 #include <mitkITKImageImport.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkInteractionConst.h>
 #include <mitkNumericTypes.h>
 #include <mitkRotationOperation.h>
 #include <mitkStandardFileLocations.h>
 #include <mitkTestingMacros.h>
 
 #include <cstdlib>
 #include <ctime>
 #include <cmath>
 
 #include <mitkGeometry3D.h>
 
 #include <vtkActor.h>
 #include <vtkImageActor.h>
 #include <vtkImageData.h>
 #include <vtkImageMapToColors.h>
 #include <vtkImageMapper.h>
 #include <vtkImageReslice.h>
 #include <vtkInteractorStyleImage.h>
 #include <vtkLookupTable.h>
 #include <vtkPlaneSource.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
 #include <vtkSmartPointer.h>
 #include <vtkTexture.h>
 
 // use this to create the test volume on the fly
 #define CREATE_VOLUME
 
 // use this to save the created volume
 //#define SAVE_VOLUME
 
 // use this to calculate the error from the sphere mathematical model to our pixel based one
 //#define CALC_TESTFAILURE_DEVIATION
 
 // use this to render an oblique slice through a specified image
 //#define SHOW_SLICE_IN_RENDER_WINDOW
 
 // use this to have infos printed in mbilog
 //#define EXTRACTOR_DEBUG
 
 /*these are the deviations calculated by the function CalcTestFailureDeviation (see for details)*/
 #define Testfailure_Deviation_Mean_128 0.853842
 
 #define Testfailure_Deviation_Volume_128 0.145184
 #define Testfailure_Deviation_Diameter_128 1.5625
 
 #define Testfailure_Deviation_Mean_256 0.397693
 
 #define Testfailure_Deviation_Volume_256 0.0141357
 #define Testfailure_Deviation_Diameter_256 0.78125
 
 #define Testfailure_Deviation_Mean_512 0.205277
 
 #define Testfailure_Deviation_Volume_512 0.01993
 #define Testfailure_Deviation_Diameter_512 0.390625
 
 class mitkExtractSliceFilterTestClass
 {
 public:
   static void TestSlice(mitk::PlaneGeometry *planeGeometry, std::string testname)
   {
     TestPlane = planeGeometry;
     TestName = testname;
 
     mitk::ScalarType centerCoordValue = TestvolumeSize / 2.0;
     mitk::ScalarType center[3] = {centerCoordValue, centerCoordValue, centerCoordValue};
     mitk::Point3D centerIndex(center);
 
     double radius = TestvolumeSize / 4.0;
     if (TestPlane->Distance(centerIndex) >= radius)
       return; // outside sphere
 
     // feed ExtractSliceFilter
     mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New();
 
     slicer->SetInput(TestVolume);
     slicer->SetWorldGeometry(TestPlane);
     slicer->Update();
 
     MITK_TEST_CONDITION_REQUIRED(slicer->GetOutput() != nullptr, "Extractor returned a slice");
 
     mitk::Image::Pointer reslicedImage = slicer->GetOutput();
 
     AccessFixedDimensionByItk(reslicedImage, TestSphereRadiusByItk, 2);
     AccessFixedDimensionByItk(reslicedImage, TestSphereAreaByItk, 2);
 
     /*
     double devArea, devDiameter;
     if(TestvolumeSize == 128.0){ devArea = Testfailure_Deviation_Volume_128; devDiameter =
     Testfailure_Deviation_Diameter_128; }
     else if(TestvolumeSize == 256.0){devArea = Testfailure_Deviation_Volume_256; devDiameter =
     Testfailure_Deviation_Diameter_256;}
     else if (TestvolumeSize == 512.0){devArea = Testfailure_Deviation_Volume_512; devDiameter =
     Testfailure_Deviation_Diameter_512;}
     else{devArea = Testfailure_Deviation_Volume_128; devDiameter = Testfailure_Deviation_Diameter_128;}
     */
 
     std::string areatestName = TestName.append(" area");
     std::string diametertestName = TestName.append(" testing diameter");
 
     // TODO think about the deviation, 1% makes no sense at all
     MITK_TEST_CONDITION(std::abs(100 - testResults.percentageAreaCalcToPixel) < 1, areatestName);
     MITK_TEST_CONDITION(std::abs(100 - testResults.percentageRadiusToPixel) < 1, diametertestName);
 
 #ifdef EXTRACTOR_DEBUG
     MITK_INFO << TestName << " >>> "
               << "planeDistanceToSphereCenter: " << testResults.planeDistanceToSphereCenter;
     MITK_INFO << "area in pixels: " << testResults.areaInPixel << " <-> area in mm: " << testResults.areaCalculated
               << " = " << testResults.percentageAreaCalcToPixel << "%";
 
     MITK_INFO << "calculated diameter: " << testResults.diameterCalculated
               << " <-> diameter in mm: " << testResults.diameterInMM
               << " <-> diameter in pixel: " << testResults.diameterInPixel << " = "
               << testResults.percentageRadiusToPixel << "%";
 #endif
   }
 
   /*
    * get the radius of the slice of a sphere based on pixel distance from edge to edge of the circle.
    */
   template <typename TPixel, unsigned int VImageDimension>
   static void TestSphereRadiusByItk(itk::Image<TPixel, VImageDimension> *inputImage)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
 
     // set the index to the middle of the image's edge at x and y axis
     typename InputImageType::IndexType currentIndexX;
     currentIndexX[0] = (int)(TestvolumeSize / 2.0);
     currentIndexX[1] = 0;
 
     typename InputImageType::IndexType currentIndexY;
     currentIndexY[0] = 0;
     currentIndexY[1] = (int)(TestvolumeSize / 2.0);
 
     // remember the last pixel value
     double lastValueX = inputImage->GetPixel(currentIndexX);
     double lastValueY = inputImage->GetPixel(currentIndexY);
 
     // storage for the index marks
     std::vector<typename InputImageType::IndexType> indicesX;
     std::vector<typename InputImageType::IndexType> indicesY;
 
     /*Get four indices on the edge of the circle*/
     while (currentIndexX[1] < TestvolumeSize && currentIndexX[0] < TestvolumeSize)
     {
       // move x direction
       currentIndexX[1] += 1;
 
       // move y direction
       currentIndexY[0] += 1;
 
       if (inputImage->GetPixel(currentIndexX) > lastValueX)
       {
         // mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexX[0];
         markIndex[1] = currentIndexX[1];
 
         indicesX.push_back(markIndex);
       }
       else if (inputImage->GetPixel(currentIndexX) < lastValueX)
       {
         // mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexX[0];
         markIndex[1] = currentIndexX[1] - 1; // value inside the sphere
 
         indicesX.push_back(markIndex);
       }
 
       if (inputImage->GetPixel(currentIndexY) > lastValueY)
       {
         // mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexY[0];
         markIndex[1] = currentIndexY[1];
 
         indicesY.push_back(markIndex);
       }
       else if (inputImage->GetPixel(currentIndexY) < lastValueY)
       {
         // mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexY[0];
         markIndex[1] = currentIndexY[1] - 1; // value inside the sphere
 
         indicesY.push_back(markIndex);
       }
 
       // found both marks?
       if (indicesX.size() == 2 && indicesY.size() == 2)
         break;
 
       // the new 'last' values
       lastValueX = inputImage->GetPixel(currentIndexX);
       lastValueY = inputImage->GetPixel(currentIndexY);
     }
 
     /*
      *If we are here we found the four marks on the edge of the circle.
      *For the case our plane is rotated and shifted, we have to calculate the center of the circle,
      *else the center is the intersection of both straight lines between the marks.
      *When we have the center, the diameter of the circle will be checked to the reference value(math!).
      */
 
     // each distance from the first mark of each direction to the center of the straight line between the marks
     double distanceToCenterX = std::abs(indicesX[0][1] - indicesX[1][1]) / 2.0;
     // double distanceToCenterY = std::abs(indicesY[0][0] - indicesY[1][0]) / 2.0;
 
     // the center of the straight lines
     typename InputImageType::IndexType centerX;
     // typename InputImageType::IndexType centerY;
 
     centerX[0] = indicesX[0][0];
     centerX[1] = indicesX[0][1] + distanceToCenterX;
     // TODO think about implicit cast to int. this is not the real center of the image, which could be between two
     // pixels
 
     // centerY[0] = indicesY[0][0] + distanceToCenterY;
     // centerY[1] = inidcesY[0][1];
 
     typename InputImageType::IndexType currentIndex(centerX);
     lastValueX = inputImage->GetPixel(currentIndex);
 
     long sumpixels = 0;
 
     std::vector<typename InputImageType::IndexType> diameterIndices;
 
     // move up
     while (currentIndex[1] < TestvolumeSize)
     {
       currentIndex[1] += 1;
 
       if (inputImage->GetPixel(currentIndex) != lastValueX)
       {
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndex[0];
         markIndex[1] = currentIndex[1] - 1;
 
         diameterIndices.push_back(markIndex);
         break;
       }
 
       sumpixels++;
       lastValueX = inputImage->GetPixel(currentIndex);
     }
 
     currentIndex[1] -= sumpixels; // move back to center to go in the other direction
     lastValueX = inputImage->GetPixel(currentIndex);
 
     // move down
     while (currentIndex[1] >= 0)
     {
       currentIndex[1] -= 1;
 
       if (inputImage->GetPixel(currentIndex) != lastValueX)
       {
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndex[0];
         markIndex[1] = currentIndex[1]; // outside sphere because we want to calculate the distance from edge to edge
 
         diameterIndices.push_back(markIndex);
         break;
       }
 
       sumpixels++;
       lastValueX = inputImage->GetPixel(currentIndex);
     }
 
     /*
     *Now sumpixels should be the apromximate diameter of the circle. This is checked with the calculated diameter from
     *the plane transformation(math).
     */
     mitk::Point3D volumeCenter;
     volumeCenter[0] = volumeCenter[1] = volumeCenter[2] = TestvolumeSize / 2.0;
 
     double planeDistanceToSphereCenter = TestPlane->Distance(volumeCenter);
 
     double sphereRadius = TestvolumeSize / 4.0;
 
     // calculate the radius of the circle cut from the sphere by the plane
     double diameter = 2.0 * std::sqrt(std::pow(sphereRadius, 2) - std::pow(planeDistanceToSphereCenter, 2));
 
     double percentageRadiusToPixel = 100 / diameter * sumpixels;
 
     /*
      *calculate the radius in mm by the both marks of the center line by using the world coordinates
      */
     // get the points as 3D coordinates
     mitk::Vector3D diameterPointRight, diameterPointLeft;
 
     diameterPointRight[2] = diameterPointLeft[2] = 0.0;
 
     diameterPointLeft[0] = diameterIndices[0][0];
     diameterPointLeft[1] = diameterIndices[0][1];
 
     diameterPointRight[0] = diameterIndices[1][0];
     diameterPointRight[1] = diameterIndices[1][1];
 
     // transform to worldcoordinates
     TestVolume->GetGeometry()->IndexToWorld(diameterPointLeft, diameterPointLeft);
     TestVolume->GetGeometry()->IndexToWorld(diameterPointRight, diameterPointRight);
 
     // euklidian distance
     double diameterInMM = ((diameterPointLeft * -1.0) + diameterPointRight).GetNorm();
 
     testResults.diameterInMM = diameterInMM;
     testResults.diameterCalculated = diameter;
     testResults.diameterInPixel = sumpixels;
     testResults.percentageRadiusToPixel = percentageRadiusToPixel;
     testResults.planeDistanceToSphereCenter = planeDistanceToSphereCenter;
   }
 
   /*brute force the area pixel by pixel*/
   template <typename TPixel, unsigned int VImageDimension>
   static void TestSphereAreaByItk(itk::Image<TPixel, VImageDimension> *inputImage)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
     typedef itk::ImageRegionConstIterator<InputImageType> ImageIterator;
 
     ImageIterator imageIterator(inputImage, inputImage->GetLargestPossibleRegion());
     imageIterator.GoToBegin();
 
     int sumPixelsInArea = 0;
 
     while (!imageIterator.IsAtEnd())
     {
       if (inputImage->GetPixel(imageIterator.GetIndex()) == pixelValueSet)
         sumPixelsInArea++;
       ++imageIterator;
     }
 
     mitk::Point3D volumeCenter;
     volumeCenter[0] = volumeCenter[1] = volumeCenter[2] = TestvolumeSize / 2.0;
 
     double planeDistanceToSphereCenter = TestPlane->Distance(volumeCenter);
 
     double sphereRadius = TestvolumeSize / 4.0;
 
     // calculate the radius of the circle cut from the sphere by the plane
     double radius = std::sqrt(std::pow(sphereRadius, 2) - std::pow(planeDistanceToSphereCenter, 2));
 
     double areaInMM = 3.14159265358979 * std::pow(radius, 2);
 
     testResults.areaCalculated = areaInMM;
     testResults.areaInPixel = sumPixelsInArea;
     testResults.percentageAreaCalcToPixel = 100 / areaInMM * sumPixelsInArea;
   }
 
   /*
    * random a voxel. define plane through this voxel. reslice at the plane. compare the pixel vaues of the voxel
    * in the volume with the pixel value in the resliced image.
    * there are some indice shifting problems which causes the test to fail for oblique planes. seems like the chosen
    * worldcoordinate is not corrresponding to the index in the 2D image. and so the pixel values are not the same as
    * expected.
    */
   static void PixelvalueBasedTest()
   {
     /* setup itk image */
     typedef itk::Image<unsigned short, 3> ImageType;
 
     typedef itk::ImageRegionConstIterator<ImageType> ImageIterator;
 
     ImageType::Pointer image = ImageType::New();
 
     ImageType::IndexType start;
     start[0] = start[1] = start[2] = 0;
 
     ImageType::SizeType size;
     size[0] = size[1] = size[2] = 32;
 
     ImageType::RegionType imgRegion;
     imgRegion.SetSize(size);
     imgRegion.SetIndex(start);
 
     image->SetRegions(imgRegion);
     image->SetSpacing(1.0);
     image->Allocate();
 
     ImageIterator imageIterator(image, image->GetLargestPossibleRegion());
     imageIterator.GoToBegin();
 
     unsigned short pixelValue = 0;
 
     // fill the image with distinct values
     while (!imageIterator.IsAtEnd())
     {
       image->SetPixel(imageIterator.GetIndex(), pixelValue);
       ++imageIterator;
       ++pixelValue;
     }
     /* end setup itk image */
 
     mitk::Image::Pointer imageInMitk;
     CastToMitkImage(image, imageInMitk);
 
     /*mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New();
     writer->SetInput(imageInMitk);
     std::string file = "C:\\Users\\schroedt\\Desktop\\cube.nrrd";
     writer->SetFileName(file);
     writer->Update();*/
 
-    PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Frontal);
+    PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Coronal);
     PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Sagittal);
     PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Axial);
   }
 
   static void PixelvalueBasedTestByPlane(mitk::Image *imageInMitk, mitk::PlaneGeometry::PlaneOrientation orientation)
   {
     typedef itk::Image<unsigned short, 3> ImageType;
 
     // set the seed of the rand function
     srand((unsigned)time(nullptr));
 
     /* setup a random orthogonal plane */
     int sliceindex = 17; // rand() % 32;
     bool isFrontside = true;
     bool isRotated = false;
 
     if (orientation == mitk::PlaneGeometry::Axial)
     {
       /*isFrontside = false;
       isRotated = true;*/
     }
 
     mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
 
     plane->InitializeStandardPlane(imageInMitk->GetGeometry(), orientation, sliceindex, isFrontside, isRotated);
 
     mitk::Point3D origin = plane->GetOrigin();
     mitk::Vector3D normal;
     normal = plane->GetNormal();
 
     normal.Normalize();
 
     origin += normal * 0.5; // pixelspacing is 1, so half the spacing is 0.5
 
     plane->SetOrigin(origin);
 
     // we dont need this any more, because we are only testing orthogonal planes
     /*mitk::Vector3D rotationVector;
     rotationVector[0] = randFloat();
     rotationVector[1] = randFloat();
     rotationVector[2] = randFloat();
 
 
     float degree = randFloat() * 180.0;
 
     mitk::RotationOperation* op = new mitk::RotationOperation(mitk::OpROTATE, plane->GetCenter(), rotationVector,
     degree);
     plane->ExecuteOperation(op);
     delete op;*/
 
     /* end setup plane */
 
     /* define a point in the 3D volume.
      * add the two axis vectors of the plane (each multiplied with a
      * random number) to the origin. now the two random numbers
      * become our index coordinates in the 2D image, because the
      * length of the axis vectors is 1.
      */
     mitk::Point3D planeOrigin = plane->GetOrigin();
     mitk::Vector3D axis0, axis1;
     axis0 = plane->GetAxisVector(0);
     axis1 = plane->GetAxisVector(1);
     axis0.Normalize();
     axis1.Normalize();
 
     unsigned char n1 = 7;  // rand() % 32;
     unsigned char n2 = 13; // rand() % 32;
 
     mitk::Point3D testPoint3DInWorld;
     testPoint3DInWorld = planeOrigin + (axis0 * n1) + (axis1 * n2);
 
     // get the index of the point in the 3D volume
     ImageType::IndexType testPoint3DInIndex;
     imageInMitk->GetGeometry()->WorldToIndex(testPoint3DInWorld, testPoint3DInIndex);
 
     itk::Index<3> testPoint2DInIndex;
 
     /* end define a point in the 3D volume.*/
 
     // do reslicing at the plane
     mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New();
     slicer->SetInput(imageInMitk);
     slicer->SetWorldGeometry(plane);
 
     slicer->Update();
 
     mitk::Image::Pointer slice = slicer->GetOutput();
 
     // Get TestPoiont3D as Index in Slice
     slice->GetGeometry()->WorldToIndex(testPoint3DInWorld, testPoint2DInIndex);
 
     mitk::Point3D p, sliceIndexToWorld, imageIndexToWorld;
     p[0] = testPoint2DInIndex[0];
     p[1] = testPoint2DInIndex[1];
     p[2] = testPoint2DInIndex[2];
     slice->GetGeometry()->IndexToWorld(p, sliceIndexToWorld);
 
     p[0] = testPoint3DInIndex[0];
     p[1] = testPoint3DInIndex[1];
     p[2] = testPoint3DInIndex[2];
     imageInMitk->GetGeometry()->IndexToWorld(p, imageIndexToWorld);
 
     itk::Index<2> testPoint2DIn2DIndex;
     testPoint2DIn2DIndex[0] = testPoint2DInIndex[0];
     testPoint2DIn2DIndex[1] = testPoint2DInIndex[1];
 
     typedef mitk::ImagePixelReadAccessor<unsigned short, 3> VolumeReadAccessorType;
     typedef mitk::ImagePixelReadAccessor<unsigned short, 2> SliceReadAccessorType;
     VolumeReadAccessorType VolumeReadAccessor(imageInMitk);
     SliceReadAccessorType SliceReadAccessor(slice);
 
     // compare the pixelvalues of the defined point in the 3D volume with the value of the resliced image
     unsigned short valueAt3DVolume = VolumeReadAccessor.GetPixelByIndex(testPoint3DInIndex);
     unsigned short valueAtSlice = SliceReadAccessor.GetPixelByIndex(testPoint2DIn2DIndex);
 
     // valueAt3DVolume == valueAtSlice is not always working. because of rounding errors
     // indices are shifted
     MITK_TEST_CONDITION(valueAt3DVolume == valueAtSlice, "comparing pixelvalues for orthogonal plane");
 
     vtkSmartPointer<vtkImageData> imageInVtk = imageInMitk->GetVtkImageData();
     vtkSmartPointer<vtkImageData> sliceInVtk = slice->GetVtkImageData();
 
     double PixelvalueByMitkOutput = sliceInVtk->GetScalarComponentAsDouble(n1, n2, 0, 0);
     // double valueVTKinImage = imageInVtk->GetScalarComponentAsDouble(testPoint3DInIndex[0], testPoint3DInIndex[1],
     // testPoint3DInIndex[2], 0);
 
     /* Test that everything is working equally if vtkoutput is used instead of the default output
      * from mitk ImageToImageFilter
      */
     mitk::ExtractSliceFilter::Pointer slicerWithVtkOutput = mitk::ExtractSliceFilter::New();
     slicerWithVtkOutput->SetInput(imageInMitk);
     slicerWithVtkOutput->SetWorldGeometry(plane);
     slicerWithVtkOutput->SetVtkOutputRequest(true);
 
     slicerWithVtkOutput->Update();
     vtkSmartPointer<vtkImageData> vtkImageByVtkOutput = slicerWithVtkOutput->GetVtkOutput();
     double PixelvalueByVtkOutput = vtkImageByVtkOutput->GetScalarComponentAsDouble(n1, n2, 0, 0);
 
     MITK_TEST_CONDITION(PixelvalueByMitkOutput == PixelvalueByVtkOutput,
                         "testing convertion of image output vtk->mitk by reslicer");
 
 /*================ mbilog outputs ===========================*/
 #ifdef EXTRACTOR_DEBUG
     MITK_INFO << "\n"
               << "TESTINFO index: " << sliceindex << " orientation: " << orientation << " frontside: " << isFrontside
               << " rotated: " << isRotated;
     MITK_INFO << "\n"
               << "slice index to world: " << sliceIndexToWorld;
     MITK_INFO << "\n"
               << "image index to world: " << imageIndexToWorld;
 
     MITK_INFO << "\n"
               << "vtk: slice: " << PixelvalueByMitkOutput << ", image: " << valueVTKinImage;
 
     MITK_INFO << "\n"
               << "testPoint3D InWorld" << testPoint3DInWorld << " is " << testPoint2DInIndex << " in 2D";
     MITK_INFO << "\n"
               << "randoms: " << ((int)n1) << ", " << ((int)n2);
     MITK_INFO << "\n"
               << "point is inside plane: " << plane->IsInside(testPoint3DInWorld)
               << " and volume: " << imageInMitk->GetGeometry()->IsInside(testPoint3DInWorld);
 
     MITK_INFO << "\n"
               << "volume idx: " << testPoint3DInIndex << " = " << valueAt3DVolume;
     MITK_INFO << "\n"
               << "volume world: " << testPoint3DInWorld << " = " << valueAt3DVolumeByWorld;
     MITK_INFO << "\n"
               << "slice idx: " << testPoint2DInIndex << " = " << valueAtSlice;
 
     itk::Index<3> curr;
     curr[0] = curr[1] = curr[2] = 0;
 
     for (int i = 0; i < 32; ++i)
     {
       for (int j = 0; j < 32; ++j)
       {
         ++curr[1];
         if (SliceReadAccessor.GetPixelByIndex(curr) == valueAt3DVolume)
         {
           MITK_INFO << "\n" << valueAt3DVolume << " MATCHED mitk " << curr;
         }
       }
       curr[1] = 0;
       ++curr[0];
     }
 
     typedef itk::Image<unsigned short, 2> Image2DType;
 
     Image2DType::Pointer img = Image2DType::New();
     CastToItkImage(slice, img);
     typedef itk::ImageRegionConstIterator<Image2DType> Iterator2D;
 
     Iterator2D iter(img, img->GetLargestPossibleRegion());
     iter.GoToBegin();
     while (!iter.IsAtEnd())
     {
       if (img->GetPixel(iter.GetIndex()) == valueAt3DVolume)
         MITK_INFO << "\n" << valueAt3DVolume << " MATCHED itk " << iter.GetIndex();
 
       ++iter;
     }
 #endif // EXTRACTOR_DEBUG
   }
 
   /* random a float value */
   static float randFloat()
   {
     return (((float)rand() + 1.0) / ((float)RAND_MAX + 1.0)) +
            (((float)rand() + 1.0) / ((float)RAND_MAX + 1.0)) / ((float)RAND_MAX + 1.0);
   }
 
   /* create a sphere with the size of the given testVolumeSize*/
   static void InitializeTestVolume()
   {
 #ifdef CREATE_VOLUME
 
     // do sphere creation
     ItkVolumeGeneration();
 
 #ifdef SAVE_VOLUME
     // save in file
     mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New();
     writer->SetInput(TestVolume);
 
     std::string file;
 
     std::ostringstream filename;
     filename << "C:\\home\\schroedt\\MITK\\Modules\\ImageExtraction\\Testing\\Data\\sphere_";
     filename << TestvolumeSize;
     filename << ".nrrd";
 
     file = filename.str();
 
     writer->SetFileName(file);
     writer->Update();
 #endif // SAVE_VOLUME
 
 #endif
 
 #ifndef CREATE_VOLUME // read from file
 
     mitk::StandardFileLocations::Pointer locator = mitk::StandardFileLocations::GetInstance();
 
     std::string filename = locator->FindFile("sphere_512.nrrd.mhd", "Modules/ImageExtraction/Testing/Data");
 
     TestVolume = mitk::IOUtil::Load<mitk::Image>(filename);
 
 #endif
 
 #ifdef CALC_TESTFAILURE_DEVIATION
     // get the TestFailureDeviation in %
     AccessFixedDimensionByItk(TestVolume, CalcTestFailureDeviation, 3);
 #endif
   }
 
   // the test result of the sphere reslice
   struct SliceProperties
   {
     double planeDistanceToSphereCenter;
     double diameterInMM;
     double diameterInPixel;
     double diameterCalculated;
     double percentageRadiusToPixel;
     double areaCalculated;
     double areaInPixel;
     double percentageAreaCalcToPixel;
   };
 
   static mitk::Image::Pointer TestVolume;
   static double TestvolumeSize;
   static mitk::PlaneGeometry::Pointer TestPlane;
   static std::string TestName;
   static unsigned char pixelValueSet;
   static SliceProperties testResults;
   static double TestFailureDeviation;
 
 private:
   /*
    * Generate a sphere with a radius of TestvolumeSize / 4.0
    */
   static void ItkVolumeGeneration()
   {
     typedef itk::Image<unsigned char, 3> TestVolumeType;
 
     typedef itk::ImageRegionConstIterator<TestVolumeType> ImageIterator;
 
     TestVolumeType::Pointer sphereImage = TestVolumeType::New();
 
     TestVolumeType::IndexType start;
     start[0] = start[1] = start[2] = 0;
 
     TestVolumeType::SizeType size;
     size[0] = size[1] = size[2] = TestvolumeSize;
 
     TestVolumeType::RegionType imgRegion;
     imgRegion.SetSize(size);
     imgRegion.SetIndex(start);
 
     sphereImage->SetRegions(imgRegion);
     sphereImage->SetSpacing(1.0);
     sphereImage->Allocate();
 
     sphereImage->FillBuffer(0);
 
     mitk::Vector3D center;
     center[0] = center[1] = center[2] = TestvolumeSize / 2.0;
 
     double radius = TestvolumeSize / 4.0;
 
     double pixelValue = pixelValueSet;
 
     ImageIterator imageIterator(sphereImage, sphereImage->GetLargestPossibleRegion());
     imageIterator.GoToBegin();
 
     mitk::Vector3D currentVoxelInIndex;
 
     while (!imageIterator.IsAtEnd())
     {
       currentVoxelInIndex[0] = imageIterator.GetIndex()[0];
       currentVoxelInIndex[1] = imageIterator.GetIndex()[1];
       currentVoxelInIndex[2] = imageIterator.GetIndex()[2];
 
       double distanceToCenter = (center + (currentVoxelInIndex * -1.0)).GetNorm();
 
       // if distance to center is smaller then the radius of the sphere
       if (distanceToCenter < radius)
       {
         sphereImage->SetPixel(imageIterator.GetIndex(), pixelValue);
       }
 
       ++imageIterator;
     }
 
     CastToMitkImage(sphereImage, TestVolume);
   }
 
   /* calculate the devation of the voxel object to the mathematical sphere object.
    * this is use to make a statement about the accuracy of the resliced image, eg. the circle's diameter or area.
    */
   template <typename TPixel, unsigned int VImageDimension>
   static void CalcTestFailureDeviation(itk::Image<TPixel, VImageDimension> *inputImage)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
     typedef itk::ImageRegionConstIterator<InputImageType> ImageIterator;
 
     ImageIterator iterator(inputImage, inputImage->GetLargestPossibleRegion());
     iterator.GoToBegin();
 
     int volumeInPixel = 0;
 
     while (!iterator.IsAtEnd())
     {
       if (inputImage->GetPixel(iterator.GetIndex()) == pixelValueSet)
         volumeInPixel++;
       ++iterator;
     }
 
     double diameter = TestvolumeSize / 2.0;
     double volumeCalculated = (1.0 / 6.0) * 3.14159265358979 * std::pow(diameter, 3);
 
     double volumeDeviation = std::abs(100 - (100 / volumeCalculated * volumeInPixel));
 
     typename InputImageType::IndexType index;
     index[0] = index[1] = TestvolumeSize / 2.0;
     index[2] = 0;
 
     int sumpixels = 0;
     while (index[2] < TestvolumeSize)
     {
       if (inputImage->GetPixel(index) == pixelValueSet)
         sumpixels++;
       index[2] += 1;
     }
 
     double diameterDeviation = std::abs(100 - (100 / diameter * sumpixels));
 #ifdef DEBUG
     MITK_INFO << "volume deviation: " << volumeDeviation << " diameter deviation:" << diameterDeviation;
 #endif
     mitkExtractSliceFilterTestClass::TestFailureDeviation = (volumeDeviation + diameterDeviation) / 2.0;
   }
 };
 /*================ #END class ================*/
 
 /*================#BEGIN Instanciation of members ================*/
 mitk::Image::Pointer mitkExtractSliceFilterTestClass::TestVolume = mitk::Image::New();
 double mitkExtractSliceFilterTestClass::TestvolumeSize = 256.0;
 mitk::PlaneGeometry::Pointer mitkExtractSliceFilterTestClass::TestPlane = mitk::PlaneGeometry::New();
 std::string mitkExtractSliceFilterTestClass::TestName = "";
 unsigned char mitkExtractSliceFilterTestClass::pixelValueSet = 255;
 mitkExtractSliceFilterTestClass::SliceProperties mitkExtractSliceFilterTestClass::testResults = {
   -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0};
 double mitkExtractSliceFilterTestClass::TestFailureDeviation = 0.0;
 /*================ #END Instanciation of members ================*/
 
 /*================ #BEGIN test main ================*/
 int mitkExtractSliceFilterTest(int /*argc*/, char * /*argv*/ [])
 {
   MITK_TEST_BEGIN("mitkExtractSliceFilterTest")
 
   // pixelvalue based testing
   mitkExtractSliceFilterTestClass::PixelvalueBasedTest();
 
   // initialize sphere test volume
   mitkExtractSliceFilterTestClass::InitializeTestVolume();
 
   mitk::Vector3D spacing = mitkExtractSliceFilterTestClass::TestVolume->GetGeometry()->GetSpacing();
 
   // the center of the sphere = center of image
   double sphereCenter = mitkExtractSliceFilterTestClass::TestvolumeSize / 2.0;
 
   double planeSize = mitkExtractSliceFilterTestClass::TestvolumeSize;
 
   /* axial plane */
   mitk::PlaneGeometry::Pointer geometryAxial = mitk::PlaneGeometry::New();
   geometryAxial->InitializeStandardPlane(
     planeSize, planeSize, spacing, mitk::PlaneGeometry::Axial, sphereCenter, false, true);
   geometryAxial->ChangeImageGeometryConsideringOriginOffset(true);
 
   mitk::Point3D origin = geometryAxial->GetOrigin();
   mitk::Vector3D normal;
   normal = geometryAxial->GetNormal();
 
   normal.Normalize();
 
   origin += normal * 0.5; // pixelspacing is 1, so half the spacing is 0.5
 
   // geometryAxial->SetOrigin(origin);
 
   mitkExtractSliceFilterTestClass::TestSlice(geometryAxial, "Testing axial plane");
   /* end axial plane */
 
   /* sagittal plane */
-  mitk::PlaneGeometry::Pointer geometrySagital = mitk::PlaneGeometry::New();
-  geometrySagital->InitializeStandardPlane(
+  mitk::PlaneGeometry::Pointer geometrySagittal = mitk::PlaneGeometry::New();
+  geometrySagittal->InitializeStandardPlane(
     planeSize, planeSize, spacing, mitk::PlaneGeometry::Sagittal, sphereCenter, true, false);
-  geometrySagital->ChangeImageGeometryConsideringOriginOffset(true);
+  geometrySagittal->ChangeImageGeometryConsideringOriginOffset(true);
 
-  origin = geometrySagital->GetOrigin();
-  normal = geometrySagital->GetNormal();
+  origin = geometrySagittal->GetOrigin();
+  normal = geometrySagittal->GetNormal();
 
   normal.Normalize();
 
   origin += normal * 0.5; // pixelspacing is 1, so half the spacing is 0.5
 
-  // geometrySagital->SetOrigin(origin);
+  // geometrySagittal->SetOrigin(origin);
 
-  mitkExtractSliceFilterTestClass::TestSlice(geometrySagital, "Testing sagittal plane");
+  mitkExtractSliceFilterTestClass::TestSlice(geometrySagittal, "Testing sagittal plane");
   /* sagittal plane */
 
   /* sagittal shifted plane */
-  mitk::PlaneGeometry::Pointer geometrySagitalShifted = mitk::PlaneGeometry::New();
-  geometrySagitalShifted->InitializeStandardPlane(
+  mitk::PlaneGeometry::Pointer geometrySagittalShifted = mitk::PlaneGeometry::New();
+  geometrySagittalShifted->InitializeStandardPlane(
     planeSize, planeSize, spacing, mitk::PlaneGeometry::Sagittal, (sphereCenter - 14), true, false);
-  geometrySagitalShifted->ChangeImageGeometryConsideringOriginOffset(true);
+  geometrySagittalShifted->ChangeImageGeometryConsideringOriginOffset(true);
 
-  origin = geometrySagitalShifted->GetOrigin();
-  normal = geometrySagitalShifted->GetNormal();
+  origin = geometrySagittalShifted->GetOrigin();
+  normal = geometrySagittalShifted->GetNormal();
 
   normal.Normalize();
 
   origin += normal * 0.5; // pixelspacing is 1, so half the spacing is 0.5
 
-  // geometrySagitalShifted->SetOrigin(origin);
+  // geometrySagittalShifted->SetOrigin(origin);
 
-  mitkExtractSliceFilterTestClass::TestSlice(geometrySagitalShifted, "Testing sagittal plane shifted");
+  mitkExtractSliceFilterTestClass::TestSlice(geometrySagittalShifted, "Testing sagittal plane shifted");
   /* end sagittal shifted plane */
 
   /* coronal plane */
   mitk::PlaneGeometry::Pointer geometryCoronal = mitk::PlaneGeometry::New();
   geometryCoronal->InitializeStandardPlane(
-    planeSize, planeSize, spacing, mitk::PlaneGeometry::Frontal, sphereCenter, true, false);
+    planeSize, planeSize, spacing, mitk::PlaneGeometry::Coronal, sphereCenter, true, false);
   geometryCoronal->ChangeImageGeometryConsideringOriginOffset(true);
 
   origin = geometryCoronal->GetOrigin();
   normal = geometryCoronal->GetNormal();
 
   normal.Normalize();
 
   origin += normal * 0.5; // pixelspacing is 1, so half the spacing is 0.5
 
   // geometryCoronal->SetOrigin(origin);
 
   mitkExtractSliceFilterTestClass::TestSlice(geometryCoronal, "Testing coronal plane");
   /* end coronal plane */
 
   /* oblique plane */
   mitk::PlaneGeometry::Pointer obliquePlane = mitk::PlaneGeometry::New();
   obliquePlane->InitializeStandardPlane(
     planeSize, planeSize, spacing, mitk::PlaneGeometry::Sagittal, sphereCenter, true, false);
   obliquePlane->ChangeImageGeometryConsideringOriginOffset(true);
 
   origin = obliquePlane->GetOrigin();
   normal = obliquePlane->GetNormal();
 
   normal.Normalize();
 
   origin += normal * 0.5; // pixelspacing is 1, so half the spacing is 0.5
 
   // obliquePlane->SetOrigin(origin);
 
   mitk::Vector3D rotationVector;
   rotationVector[0] = 0.2;
   rotationVector[1] = 0.4;
   rotationVector[2] = 0.62;
 
   float degree = 37.0;
 
   mitk::RotationOperation *op =
     new mitk::RotationOperation(mitk::OpROTATE, obliquePlane->GetCenter(), rotationVector, degree);
   obliquePlane->ExecuteOperation(op);
   delete op;
 
   mitkExtractSliceFilterTestClass::TestSlice(obliquePlane, "Testing oblique plane");
 /* end oblique plane */
 
 #ifdef SHOW_SLICE_IN_RENDER_WINDOW
   /*================ #BEGIN vtk render code ================*/
 
   // set reslicer for renderwindow
 
   mitk::Image::Pointer pic = mitk::IOUtil::Load<mitk::Image>(filename);
   vtkSmartPointer<vtkImageReslice> slicer = vtkSmartPointer<vtkImageReslice>::New();
 
   slicer->SetInput(pic->GetVtkImageData());
 
   mitk::PlaneGeometry::Pointer obliquePl = mitk::PlaneGeometry::New();
   obliquePl->InitializeStandardPlane(
     pic->GetGeometry(), mitk::PlaneGeometry::Sagittal, pic->GetGeometry()->GetCenter()[0], true, false);
   obliquePl->ChangeImageGeometryConsideringOriginOffset(true);
 
   mitk::Point3D origin2 = obliquePl->GetOrigin();
   mitk::Vector3D n;
   n = obliquePl->GetNormal();
 
   n.Normalize();
 
   origin2 += n * 0.5; // pixelspacing is 1, so half the spacing is 0.5
 
   obliquePl->SetOrigin(origin2);
 
   mitk::Vector3D rotation;
   rotation[0] = 0.534307;
   rotation[1] = 0.000439605;
   rotation[2] = 0.423017;
   MITK_INFO << rotation;
 
   mitk::RotationOperation *operation =
     new mitk::RotationOperation(mitk::OpROTATE, obliquePl->GetCenter(), rotationVector, degree);
   obliquePl->ExecuteOperation(operation);
   delete operation;
 
   double origin[3];
   origin[0] = obliquePl->GetOrigin()[0];
   origin[1] = obliquePl->GetOrigin()[1];
   origin[2] = obliquePl->GetOrigin()[2];
   slicer->SetResliceAxesOrigin(origin);
 
   mitk::Vector3D right, bottom, normal;
   right = obliquePl->GetAxisVector(0);
   bottom = obliquePl->GetAxisVector(1);
   normal = obliquePl->GetNormal();
 
   right.Normalize();
   bottom.Normalize();
   normal.Normalize();
 
   double cosines[9];
 
   mitk::vnl2vtk(right.GetVnlVector(), cosines); // x
 
   mitk::vnl2vtk(bottom.GetVnlVector(), cosines + 3); // y
 
   mitk::vnl2vtk(normal.GetVnlVector(), cosines + 6); // n
 
   slicer->SetResliceAxesDirectionCosines(cosines);
 
   slicer->SetOutputDimensionality(2);
   slicer->Update();
 
   // set vtk renderwindow
   vtkSmartPointer<vtkPlaneSource> vtkPlane = vtkSmartPointer<vtkPlaneSource>::New();
   vtkPlane->SetOrigin(0.0, 0.0, 0.0);
 
   // These two points define the axes of the plane in combination with the origin.
   // Point 1 is the x-axis and point 2 the y-axis.
-  // Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
+  // Each plane is transformed according to the view (axial, coronal and sagittal) afterwards.
   vtkPlane->SetPoint1(1.0, 0.0, 0.0); // P1: (xMax, yMin, depth)
   vtkPlane->SetPoint2(0.0, 1.0, 0.0); // P2: (xMin, yMax, depth)
   // these are not the correct values for all slices, only a square plane by now
 
   vtkSmartPointer<vtkPolyDataMapper> imageMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   imageMapper->SetInputConnection(vtkPlane->GetOutputPort());
 
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
 
   // built a default lookuptable
   lookupTable->SetRampToLinear();
   lookupTable->SetSaturationRange(0.0, 0.0);
   lookupTable->SetHueRange(0.0, 0.0);
   lookupTable->SetValueRange(0.0, 1.0);
   lookupTable->Build();
   // map all black values to transparent
   lookupTable->SetTableValue(0, 0.0, 0.0, 0.0, 0.0);
   lookupTable->SetRange(-255.0, 255.0);
   // lookupTable->SetRange(-1022.0, 1184.0);//pic3D range
 
   vtkSmartPointer<vtkTexture> texture = vtkSmartPointer<vtkTexture>::New();
 
   texture->SetInput(slicer->GetOutput());
 
   texture->SetLookupTable(lookupTable);
 
   texture->SetMapColorScalarsThroughLookupTable(true);
 
   vtkSmartPointer<vtkActor> imageActor = vtkSmartPointer<vtkActor>::New();
   imageActor->SetMapper(imageMapper);
   imageActor->SetTexture(texture);
 
   // Setup renderers
   vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
   renderer->AddActor(imageActor);
 
   // Setup render window
   vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
   renderWindow->AddRenderer(renderer);
 
   // Setup render window interactor
   vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
   vtkSmartPointer<vtkInteractorStyleImage> style = vtkSmartPointer<vtkInteractorStyleImage>::New();
   renderWindowInteractor->SetInteractorStyle(style);
 
   // Render and start interaction
   renderWindowInteractor->SetRenderWindow(renderWindow);
   // renderer->AddViewProp(imageActor);
 
   renderWindow->Render();
   renderWindowInteractor->Start();
 // always end with this!
 /*================ #END vtk render code ================*/
 #endif // SHOW_SLICE_IN_RENDER_WINDOW
 
   MITK_TEST_END()
 }
diff --git a/Modules/Core/test/mitkImageVtkMapper2DOpacityTest.cpp b/Modules/Core/test/mitkImageVtkMapper2DOpacityTest.cpp
index 8ad5170b3b..de502162ab 100644
--- a/Modules/Core/test/mitkImageVtkMapper2DOpacityTest.cpp
+++ b/Modules/Core/test/mitkImageVtkMapper2DOpacityTest.cpp
@@ -1,54 +1,54 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // MITK
 #include "mitkRenderingTestHelper.h"
 #include "mitkTestingMacros.h"
 
 // VTK
 #include <vtkRegressionTestImage.h>
 
 int mitkImageVtkMapper2DOpacityTest(int argc, char *argv[])
 {
   try
   {
     mitk::RenderingTestHelper openGlTest(640, 480);
   }
   catch (const mitk::TestNotRunException &e)
   {
     MITK_WARN << "Test not run: " << e.GetDescription();
     return 77;
   }
   // load all arguments into a datastorage, take last argument as reference rendering
   // setup a renderwindow of fixed size X*Y
   // render the datastorage
   // compare rendering to reference image
   MITK_TEST_BEGIN("mitkImageVtkMapper2DTest")
 
   mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
   // Set the opacity for all images
   renderingHelper.SetImageProperty("opacity", mitk::FloatProperty::New(0.5f));
   // for now this test renders in coronal view direction
-  renderingHelper.SetViewDirection(mitk::SliceNavigationController::Frontal);
+  renderingHelper.SetViewDirection(mitk::SliceNavigationController::Coronal);
 
   //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
   MITK_TEST_CONDITION(renderingHelper.CompareRenderWindowAgainstReference(argc, argv) == true,
                       "CompareRenderWindowAgainstReference test result positive?");
 
   // use this to generate a reference screenshot or save the file:
   if (false)
   {
     renderingHelper.SaveReferenceScreenShot("d:/tmp/renderingtest.png");
   }
 
   MITK_TEST_END();
 }
diff --git a/Modules/Core/test/mitkPlaneGeometryDataMapper2DTest.cpp b/Modules/Core/test/mitkPlaneGeometryDataMapper2DTest.cpp
index 20c5313823..40c94aeff0 100644
--- a/Modules/Core/test/mitkPlaneGeometryDataMapper2DTest.cpp
+++ b/Modules/Core/test/mitkPlaneGeometryDataMapper2DTest.cpp
@@ -1,98 +1,98 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // MITK
 #include "mitkRenderingTestHelper.h"
 #include "mitkTestingMacros.h"
 
 #include <mitkNodePredicateDataType.h>
 
 #include <mitkPlaneGeometryData.h>
 
 // VTK
 #include <vtkRegressionTestImage.h>
 
 mitk::DataNode::Pointer addPlaneToDataStorage(mitk::RenderingTestHelper &renderingHelper,
                                               mitk::Image *image,
                                               mitk::PlaneGeometry::PlaneOrientation orientation,
                                               mitk::ScalarType zPos)
 {
   auto geometry = mitk::PlaneGeometry::New();
   geometry->InitializeStandardPlane(image->GetGeometry(), orientation, zPos);
 
   auto geometryData = mitk::PlaneGeometryData::New();
   geometryData->SetPlaneGeometry(geometry);
 
   auto node = mitk::DataNode::New();
   node->SetData(geometryData);
 
   renderingHelper.AddNodeToStorage(node);
 
   return node;
 }
 
 int mitkPlaneGeometryDataMapper2DTest(int argc, char *argv[])
 {
   try
   {
     mitk::RenderingTestHelper openGlTest(640, 480);
   }
   catch (const mitk::TestNotRunException &e)
   {
     MITK_WARN << "Test not run: " << e.GetDescription();
     return 77;
   }
   // load all arguments into a datastorage, take last argument as reference rendering
   // setup a renderwindow of fixed size X*Y
   // render the datastorage
   // compare rendering to reference image
   MITK_TEST_BEGIN("mitkPlaneGeometryDataMapper2DTest")
 
   mitk::RenderingTestHelper renderingHelper(640, 480, argc, argv);
   auto image = static_cast<mitk::Image *>(
     renderingHelper.GetDataStorage()->GetNode(mitk::TNodePredicateDataType<mitk::Image>::New())->GetData());
 
   auto zCoord = image->GetGeometry()->GetBoundingBox()->GetCenter()[0];
   addPlaneToDataStorage(renderingHelper, image, mitk::PlaneGeometry::Sagittal, zCoord);
-  addPlaneToDataStorage(renderingHelper, image, mitk::PlaneGeometry::Frontal, zCoord);
+  addPlaneToDataStorage(renderingHelper, image, mitk::PlaneGeometry::Coronal, zCoord);
 
   auto planeNode = addPlaneToDataStorage(renderingHelper, image, mitk::PlaneGeometry::Sagittal, zCoord);
   auto planeGeometry = static_cast<mitk::PlaneGeometryData *>(planeNode->GetData())->GetPlaneGeometry();
 
   auto transform = mitk::AffineTransform3D::New();
   mitk::Vector3D rotationAxis;
   rotationAxis.Fill(0.0);
   rotationAxis[2] = 1;
   transform->Rotate3D(rotationAxis, vnl_math::pi_over_4);
 
   planeGeometry->Compose(transform);
 
   auto bounds = planeGeometry->GetBounds();
   bounds[1] /= 3;
   planeGeometry->SetBounds(bounds);
 
   planeGeometry->SetReferenceGeometry(nullptr);
 
   planeNode->SetIntProperty("Crosshair.Gap Size", 4);
 
   //### Usage of CompareRenderWindowAgainstReference: See docu of mitkRrenderingTestHelper
   MITK_TEST_CONDITION(renderingHelper.CompareRenderWindowAgainstReference(argc, argv, 1) == true,
                       "CompareRenderWindowAgainstReference test result positive?");
 
   // use this to generate a reference screenshot or save the file:
   if (false)
   {
     renderingHelper.SaveReferenceScreenShot("output.png");
   }
 
   MITK_TEST_END();
 }
diff --git a/Modules/Core/test/mitkPlaneGeometryTest.cpp b/Modules/Core/test/mitkPlaneGeometryTest.cpp
index 0307e36536..f255f79b46 100644
--- a/Modules/Core/test/mitkPlaneGeometryTest.cpp
+++ b/Modules/Core/test/mitkPlaneGeometryTest.cpp
@@ -1,1093 +1,1093 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkAffineTransform3D.h"
 #include "mitkBaseGeometry.h"
 #include "mitkGeometry3D.h"
 #include "mitkInteractionConst.h"
 #include "mitkLine.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkRotationOperation.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkThinPlateSplineCurvedGeometry.h"
 
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 #include <vnl/vnl_quaternion.h>
 #include <vnl/vnl_quaternion.hxx>
 
 #include <fstream>
 #include <iomanip>
 #include <mitkIOUtil.h>
 #include <mitkImage.h>
 
 static const mitk::ScalarType testEps = 1E-9; // the epsilon used in this test == at least float precision.
 
 class mitkPlaneGeometryTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkPlaneGeometryTestSuite);
   MITK_TEST(TestInitializeStandardPlane);
   MITK_TEST(TestProjectPointOntoPlane);
   MITK_TEST(TestPlaneGeometryCloning);
   MITK_TEST(TestInheritance);
   MITK_TEST(TestSetExtendInMM);
   MITK_TEST(TestRotate);
   MITK_TEST(TestClone);
   MITK_TEST(TestPlaneComparison);
   MITK_TEST(TestAxialInitialization);
-  MITK_TEST(TestFrontalInitialization);
-  MITK_TEST(TestSaggitalInitialization);
+  MITK_TEST(TestCoronalInitialization);
+  MITK_TEST(TestSagittalInitialization);
   MITK_TEST(TestLefthandedCoordinateSystem);
   MITK_TEST(TestDominantAxesError);
   MITK_TEST(TestCheckRotationMatrix);
 
   // Currently commented out, see See bug 15990
   // MITK_TEST(testPlaneGeometryInitializeOrder);
   MITK_TEST(TestIntersectionPoint);
   MITK_TEST(TestCase1210);
 
   CPPUNIT_TEST_SUITE_END();
 
 private:
   // private test members that are initialized by setUp()
   mitk::PlaneGeometry::Pointer planegeometry;
   mitk::Point3D origin;
   mitk::Vector3D right, bottom, normal, spacing;
   mitk::ScalarType width, height;
   mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
 
 public:
   void setUp() override
   {
     planegeometry = mitk::PlaneGeometry::New();
     width = 100;
     widthInMM = width;
     height = 200;
     heightInMM = height;
     thicknessInMM = 1.0;
     mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
     mitk::FillVector3D(right, widthInMM, 0, 0);
     mitk::FillVector3D(bottom, 0, heightInMM, 0);
     mitk::FillVector3D(normal, 0, 0, thicknessInMM);
     mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
 
     planegeometry->InitializeStandardPlane(right, bottom);
     planegeometry->SetOrigin(origin);
     planegeometry->SetSpacing(spacing);
   }
 
   void tearDown() override {}
   // This test verifies inheritance behaviour, this test will fail if the behaviour changes in the future
   void TestInheritance()
   {
     mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
     mitk::Geometry3D::Pointer g3d = dynamic_cast<mitk::Geometry3D *>(plane.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Planegeometry should not be castable to Geometry 3D", g3d.IsNull());
 
     mitk::BaseGeometry::Pointer base = dynamic_cast<mitk::BaseGeometry *>(plane.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Planegeometry should be castable to BaseGeometry", base.IsNotNull());
 
     g3d = mitk::Geometry3D::New();
     base = dynamic_cast<mitk::BaseGeometry *>(g3d.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Geometry3D should be castable to BaseGeometry", base.IsNotNull());
 
     mitk::SlicedGeometry3D::Pointer sliced = mitk::SlicedGeometry3D::New();
     g3d = dynamic_cast<mitk::Geometry3D *>(sliced.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("SlicedGeometry3D should not be castable to Geometry3D", g3d.IsNull());
 
     mitk::ThinPlateSplineCurvedGeometry::Pointer thin = mitk::ThinPlateSplineCurvedGeometry::New();
     plane = dynamic_cast<mitk::PlaneGeometry *>(thin.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("AbstractTransformGeometry should be castable to PlaneGeometry", plane.IsNotNull());
 
     plane = mitk::PlaneGeometry::New();
     mitk::AbstractTransformGeometry::Pointer atg = dynamic_cast<mitk::AbstractTransformGeometry *>(plane.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("PlaneGeometry should not be castable to AbstractTransofrmGeometry", atg.IsNull());
   }
 
   void TestDominantAxesError()
   {
     auto image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("NotQuiteARotationMatrix.nrrd"));
     auto matrix = image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().transpose();
     std::vector< int > axes = mitk::PlaneGeometry::CalculateDominantAxes(matrix);
     CPPUNIT_ASSERT_MESSAGE("Domiant axes cannot be determined in this dataset. Output should be default ordering.", axes.at(0)==0 && axes.at(1)==1 && axes.at(2)==2);
   }
 
   void TestCheckRotationMatrix()
   {
     auto image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("NotQuiteARotationMatrix.nrrd"));
     bool is_rotation = mitk::PlaneGeometry::CheckRotationMatrix(image->GetGeometry()->GetIndexToWorldTransform(), 1e-8);
     CPPUNIT_ASSERT_MESSAGE("Since the test data matrix is not quite a rotation matrix, this should be detected.", !is_rotation);
   }
 
   void TestLefthandedCoordinateSystem()
   {
     /**
      * @brief This method tests InitializeStandardPlane() and IndexToWorld()
      * with a left-handed coordinate orientation or indexToWorldMatrix.
      *
      * Of course this test does not use standard Parameters, which are right-handed.
      * See also discussion of bug #11477: http://bugs.mitk.org/show_bug.cgi?id=11477
      */
     planegeometry = mitk::PlaneGeometry::New();
     width = 100;
     widthInMM = 5;
     height = 200;
     heightInMM = 3;
     thicknessInMM = 1.0;
     mitk::FillVector3D(right, widthInMM, 0, 0);
     mitk::FillVector3D(bottom, 0, heightInMM, 0);
     // This one negative sign results in lefthanded coordinate orientation and det(matrix) < 0.
     mitk::FillVector3D(normal, 0, 0, -thicknessInMM);
 
     mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
 
     mitk::AffineTransform3D::MatrixType matrix;
     mitk::AffineTransform3D::MatrixType::InternalMatrixType &vnl_matrix = matrix.GetVnlMatrix();
 
     vnl_matrix.set_column(0, right);
     vnl_matrix.set_column(1, bottom);
     vnl_matrix.set_column(2, normal);
 
     // making sure that we didn't screw up this special test case or else fail deadly:
     assert(vnl_determinant(vnl_matrix) < 0.0);
 
     transform->SetIdentity();
     transform->SetMatrix(matrix);
 
     planegeometry->InitializeStandardPlane(width, height, transform); // Crux of the matter.
     CPPUNIT_ASSERT_MESSAGE(
       "Testing if IndexToWorldMatrix is correct after InitializeStandardPlane( width, height, transform ) ",
       mitk::MatrixEqualElementWise(planegeometry->GetIndexToWorldTransform()->GetMatrix(), matrix));
 
     mitk::Point3D p_index;
     p_index[0] = 10.;
     p_index[1] = 10.;
     p_index[2] = 0.;
     mitk::Point3D p_world;
     mitk::Point3D p_expectedResult;
     p_expectedResult[0] = 50.;
     p_expectedResult[1] = 30.;
     p_expectedResult[2] = 0.;
 
     ((mitk::BaseGeometry::Pointer)planegeometry)->IndexToWorld(p_index, p_world); // Crux of the matter.
     CPPUNIT_ASSERT_MESSAGE("Testing if IndexToWorld(a,b) function works correctly with lefthanded matrix ",
                            mitk::Equal(p_world, p_expectedResult, testEps));
   }
 
   // See bug 1210
   // Test does not use standard Parameters
   void TestCase1210()
   {
     mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
 
     mitk::Point3D origin;
     mitk::Vector3D right, down, spacing;
 
     mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
     mitk::FillVector3D(right, 1.015625, 1.015625, 1.1999969482421875);
 
     mitk::FillVector3D(down, 1.4012984643248170709237295832899161312802619418765e-45, 0, 0);
     mitk::FillVector3D(spacing,
                        0,
                        1.4713633875410579244699160624544119378442750389703e-43,
                        9.2806360452222355258639080851310540729807238879469e-32);
 
     std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing = nullptr): " << std::endl;
     CPPUNIT_ASSERT_NO_THROW(planegeometry->InitializeStandardPlane(right, down, &spacing));
     /*
     std::cout << "Testing width, height and thickness (in units): ";
     if((mitk::Equal(planegeometry->GetExtent(0),width)==false) ||
     (mitk::Equal(planegeometry->GetExtent(1),height)==false) ||
     (mitk::Equal(planegeometry->GetExtent(2),1)==false)
     )
     {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
     }
     std::cout<<"[PASSED]"<<std::endl;
 
     std::cout << "Testing width, height and thickness (in mm): ";
     if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM)==false) ||
     (mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM)==false) ||
     (mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM)==false)
     )
     {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
     }
      */
   }
 
   /**
    * @brief This method tests method IntersectionPoint
    *
    * See also bug #7151. (ref 2 this test: iggy)
    * This test was written due to incorrect calculation of the intersection point
    * between a given line and plane. This only occured when the pointdistance of
    * the line was less than 1.
    * Test Behavour:
    * ==============
    * we have a given line and a given plane.
    * we let the line intersect the plane.
    * when testing several positions on the line the resulting intersection point must be the same
    * we test a position where the distance between the correspoinding points is < 0 and another position where the
    * distance is > 0.
    *
    */
   // Test does not use standard Parameters
   void TestIntersectionPoint()
   {
     // init plane with its parameter
     mitk::PlaneGeometry::Pointer myPlaneGeometry = mitk::PlaneGeometry::New();
 
     mitk::Point3D origin;
     origin[0] = 0.0;
     origin[1] = 2.0;
     origin[2] = 0.0;
 
     mitk::Vector3D normal;
     normal[0] = 0.0;
     normal[1] = 1.0;
     normal[2] = 0.0;
 
     myPlaneGeometry->InitializePlane(origin, normal);
 
     // generate points and line for intersection testing
     // point distance of given line > 1
     mitk::Point3D pointP1;
     pointP1[0] = 2.0;
     pointP1[1] = 1.0;
     pointP1[2] = 0.0;
 
     mitk::Point3D pointP2;
     pointP2[0] = 2.0;
     pointP2[1] = 4.0;
     pointP2[2] = 0.0;
 
     mitk::Vector3D lineDirection;
     lineDirection[0] = pointP2[0] - pointP1[0];
     lineDirection[1] = pointP2[1] - pointP1[1];
     lineDirection[2] = pointP2[2] - pointP1[2];
 
     mitk::Line3D xingline(pointP1, lineDirection);
     mitk::Point3D calcXingPoint;
     myPlaneGeometry->IntersectionPoint(xingline, calcXingPoint);
 
     // point distance of given line < 1
     mitk::Point3D pointP3;
     pointP3[0] = 2.0;
     pointP3[1] = 2.2;
     pointP3[2] = 0.0;
 
     mitk::Point3D pointP4;
     pointP4[0] = 2.0;
     pointP4[1] = 1.7;
     pointP4[2] = 0.0;
 
     mitk::Vector3D lineDirection2;
     lineDirection2[0] = pointP4[0] - pointP3[0];
     lineDirection2[1] = pointP4[1] - pointP3[1];
     lineDirection2[2] = pointP4[2] - pointP3[2];
 
     mitk::Line3D xingline2(pointP3, lineDirection2);
     mitk::Point3D calcXingPoint2;
     myPlaneGeometry->IntersectionPoint(xingline2, calcXingPoint2);
 
     // intersection points must be the same
     CPPUNIT_ASSERT_MESSAGE("Failed to calculate Intersection Point", calcXingPoint == calcXingPoint2);
   }
 
   /**
    * @brief This method tests method ProjectPointOntoPlane.
    *
    * See also bug #3409.
    */
   // Test does not use standard Parameters
   void TestProjectPointOntoPlane()
   {
     mitk::PlaneGeometry::Pointer myPlaneGeometry = mitk::PlaneGeometry::New();
 
     // create normal
     mitk::Vector3D normal;
     normal[0] = 0.0;
     normal[1] = 0.0;
     normal[2] = 1.0;
 
     // create origin
     mitk::Point3D origin;
     origin[0] = -27.582859;
     origin[1] = 50;
     origin[2] = 200.27742;
 
     // initialize plane geometry
     myPlaneGeometry->InitializePlane(origin, normal);
 
     // output to descripe the test
     std::cout << "Testing PlaneGeometry according to bug #3409" << std::endl;
     std::cout << "Our normal is: " << normal << std::endl;
     std::cout << "So ALL projected points should have exactly the same z-value!" << std::endl;
 
     // create a number of points
     mitk::Point3D myPoints[5];
     myPoints[0][0] = -27.582859;
     myPoints[0][1] = 50.00;
     myPoints[0][2] = 200.27742;
 
     myPoints[1][0] = -26.58662;
     myPoints[1][1] = 50.00;
     myPoints[1][2] = 200.19026;
 
     myPoints[2][0] = -26.58662;
     myPoints[2][1] = 50.00;
     myPoints[2][2] = 200.33124;
 
     myPoints[3][0] = 104.58662;
     myPoints[3][1] = 452.12313;
     myPoints[3][2] = 866.41236;
 
     myPoints[4][0] = -207.58662;
     myPoints[4][1] = 312.00;
     myPoints[4][2] = -300.12346;
 
     // project points onto plane
     mitk::Point3D myProjectedPoints[5];
     for (unsigned int i = 0; i < 5; ++i)
     {
       myProjectedPoints[i] = myPlaneGeometry->ProjectPointOntoPlane(myPoints[i]);
     }
 
     // compare z-values with z-value of plane (should be equal)
     bool allPointsOnPlane = true;
     for (auto &myProjectedPoint : myProjectedPoints)
     {
       if (fabs(myProjectedPoint[2] - origin[2]) > mitk::sqrteps)
       {
         allPointsOnPlane = false;
       }
     }
     CPPUNIT_ASSERT_MESSAGE("All points lie not on the same plane", allPointsOnPlane);
   }
 
   void TestPlaneGeometryCloning()
   {
     mitk::PlaneGeometry::Pointer geometry2D = createPlaneGeometry();
 
     try
     {
       mitk::PlaneGeometry::Pointer clone = geometry2D->Clone();
       itk::Matrix<mitk::ScalarType, 3, 3> matrix = clone->GetIndexToWorldTransform()->GetMatrix();
       CPPUNIT_ASSERT_MESSAGE("Test if matrix element exists...", matrix[0][0] == 31);
 
       double origin = geometry2D->GetOrigin()[0];
       CPPUNIT_ASSERT_MESSAGE("First Point of origin as expected...", mitk::Equal(origin, 8));
 
       double spacing = geometry2D->GetSpacing()[0];
       CPPUNIT_ASSERT_MESSAGE("First Point of spacing as expected...", mitk::Equal(spacing, 31));
     }
     catch (...)
     {
       CPPUNIT_FAIL("Error during access on a member of cloned geometry");
     }
     // direction [row] [coloum]
     MITK_TEST_OUTPUT(<< "Casting a rotated 2D ITK Image to a MITK Image and check if Geometry is still same");
   }
 
   void TestPlaneGeometryInitializeOrder()
   {
     mitk::Vector3D mySpacing;
     mySpacing[0] = 31;
     mySpacing[1] = 0.1;
     mySpacing[2] = 5.4;
     mitk::Point3D myOrigin;
     myOrigin[0] = 8;
     myOrigin[1] = 9;
     myOrigin[2] = 10;
     mitk::AffineTransform3D::Pointer myTransform = mitk::AffineTransform3D::New();
     itk::Matrix<mitk::ScalarType, 3, 3> transMatrix;
     transMatrix.Fill(0);
     transMatrix[0][0] = 1;
     transMatrix[1][1] = 2;
     transMatrix[2][2] = 4;
 
     myTransform->SetMatrix(transMatrix);
 
     mitk::PlaneGeometry::Pointer geometry2D1 = mitk::PlaneGeometry::New();
     geometry2D1->SetIndexToWorldTransform(myTransform);
     geometry2D1->SetSpacing(mySpacing);
     geometry2D1->SetOrigin(myOrigin);
 
     mitk::PlaneGeometry::Pointer geometry2D2 = mitk::PlaneGeometry::New();
     geometry2D2->SetSpacing(mySpacing);
     geometry2D2->SetOrigin(myOrigin);
     geometry2D2->SetIndexToWorldTransform(myTransform);
 
     mitk::PlaneGeometry::Pointer geometry2D3 = mitk::PlaneGeometry::New();
     geometry2D3->SetIndexToWorldTransform(myTransform);
     geometry2D3->SetSpacing(mySpacing);
     geometry2D3->SetOrigin(myOrigin);
     geometry2D3->SetIndexToWorldTransform(myTransform);
 
     CPPUNIT_ASSERT_MESSAGE("Origin of Geometry 1 matches that of Geometry 2.",
                            mitk::Equal(geometry2D1->GetOrigin(), geometry2D2->GetOrigin()));
     CPPUNIT_ASSERT_MESSAGE("Origin of Geometry 1 match those of Geometry 3.",
                            mitk::Equal(geometry2D1->GetOrigin(), geometry2D3->GetOrigin()));
     CPPUNIT_ASSERT_MESSAGE("Origin of Geometry 2 match those of Geometry 3.",
                            mitk::Equal(geometry2D2->GetOrigin(), geometry2D3->GetOrigin()));
 
     CPPUNIT_ASSERT_MESSAGE("Spacing of Geometry 1 match those of Geometry 2.",
                            mitk::Equal(geometry2D1->GetSpacing(), geometry2D2->GetSpacing()));
     CPPUNIT_ASSERT_MESSAGE("Spacing of Geometry 1 match those of Geometry 3.",
                            mitk::Equal(geometry2D1->GetSpacing(), geometry2D3->GetSpacing()));
     CPPUNIT_ASSERT_MESSAGE("Spacing of Geometry 2 match those of Geometry 3.",
                            mitk::Equal(geometry2D2->GetSpacing(), geometry2D3->GetSpacing()));
 
     CPPUNIT_ASSERT_MESSAGE("Transformation of Geometry 1 match those of Geometry 2.",
                            compareMatrix(geometry2D1->GetIndexToWorldTransform()->GetMatrix(),
                                          geometry2D2->GetIndexToWorldTransform()->GetMatrix()));
     CPPUNIT_ASSERT_MESSAGE("Transformation of Geometry 1 match those of Geometry 3.",
                            compareMatrix(geometry2D1->GetIndexToWorldTransform()->GetMatrix(),
                                          geometry2D3->GetIndexToWorldTransform()->GetMatrix()));
     CPPUNIT_ASSERT_MESSAGE("Transformation of Geometry 2 match those of Geometry 3.",
                            compareMatrix(geometry2D2->GetIndexToWorldTransform()->GetMatrix(),
                                          geometry2D3->GetIndexToWorldTransform()->GetMatrix()));
   }
 
   void TestInitializeStandardPlane()
   {
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: width",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: height",
                            mitk::Equal(planegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: depth",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: width in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: heght in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: depth in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: AxisVectorRight",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: AxisVectorBottom",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: AxisVectorNormal",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     mitk::Vector3D spacing;
     thicknessInMM = 1.5;
     normal.Normalize();
     normal *= thicknessInMM;
     mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
     planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
 
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: width",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: height",
                            mitk::Equal(planegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: depth",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: width in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: height in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: depth in mm",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: AxisVectorRight",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: AxisVectorBottom",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: AxisVectorNormal",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     ;
   }
 
   void TestSetExtendInMM()
   {
     normal.Normalize();
     normal *= thicknessInMM;
     planegeometry->SetExtentInMM(2, thicknessInMM);
     CPPUNIT_ASSERT_MESSAGE("Testing SetExtentInMM(2, ...), querying by GetExtentInMM(2): ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing SetExtentInMM(2, ...), querying by GetAxisVector(2) and comparing to normal: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     planegeometry->SetOrigin(origin);
     CPPUNIT_ASSERT_MESSAGE("Testing SetOrigin", mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() after SetOrigin: Right",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() after SetOrigin: Bottom",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() after SetOrigin: Normal",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   }
 
   void TestRotate()
   {
     // Changing the IndexToWorldTransform to a rotated version by SetIndexToWorldTransform() (keep origin):
     mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
     mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
     vnlmatrix = planegeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
     mitk::VnlVector axis(3);
     mitk::FillVector3D(axis, 1.0, 1.0, 1.0);
     axis.normalize();
     vnl_quaternion<mitk::ScalarType> rotation(axis, 0.223);
     vnlmatrix = rotation.rotation_matrix_transpose() * vnlmatrix;
     mitk::Matrix3D matrix;
     matrix = vnlmatrix;
     transform->SetMatrix(matrix);
     transform->SetOffset(planegeometry->GetIndexToWorldTransform()->GetOffset());
 
     right.SetVnlVector(rotation.rotation_matrix_transpose() * right.GetVnlVector());
     bottom.SetVnlVector(rotation.rotation_matrix_transpose() * bottom.GetVnlVector());
     normal.SetVnlVector(rotation.rotation_matrix_transpose() * normal.GetVnlVector());
     planegeometry->SetIndexToWorldTransform(transform);
 
     // The origin changed,because m_Origin=m_IndexToWorldTransform->GetOffset()+GetAxisVector(2)*0.5
     // and the AxisVector changes due to the rotation. In other words: the rotation was done around
     // the corner of the box, not around the planes origin. Now change it to a rotation around
     // the origin, simply by re-setting the origin to the original one:
     planegeometry->SetOrigin(origin);
 
     CPPUNIT_ASSERT_MESSAGE("Testing whether SetIndexToWorldTransform kept origin: ",
                            mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
 
     mitk::Point2D point;
     point[0] = 4;
     point[1] = 3;
     mitk::Point2D dummy;
     planegeometry->WorldToIndex(point, dummy);
     planegeometry->IndexToWorld(dummy, dummy);
     CPPUNIT_ASSERT_MESSAGE("Testing consistency of index and world coordinates.", dummy == point);
 
     CPPUNIT_ASSERT_MESSAGE("Testing width of rotated version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height of rotated version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness of rotated version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of rotated version: right ",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of rotated version: bottom",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of rotated version: normal",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(0).GetNorm(), planegeometry->GetExtentInMM(0), testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(1).GetNorm(), planegeometry->GetExtentInMM(1), testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(2).GetNorm(), planegeometry->GetExtentInMM(2), testEps));
 
     mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
 
     width *= 2;
     height *= 3;
     planegeometry->SetSizeInUnits(width, height);
     CPPUNIT_ASSERT_MESSAGE("Testing SetSizeInUnits() of rotated version: ",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing SetSizeInUnits() of rotated version: ",
                            mitk::Equal(planegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing SetSizeInUnits() of rotated version: ",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of version with changed size in units: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of version with changed size in units: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of version with changed size in units: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of version with changed size in units: right ",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of version with changed size in units: bottom",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of version with changed size in units: normal",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(0).GetNorm(), planegeometry->GetExtentInMM(0), testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(1).GetNorm(), planegeometry->GetExtentInMM(1), testEps));
     CPPUNIT_ASSERT_MESSAGE(
       "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
       mitk::Equal(planegeometry->GetAxisVector(2).GetNorm(), planegeometry->GetExtentInMM(2), testEps));
 
     mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   }
 
   void TestClone()
   {
     mitk::PlaneGeometry::Pointer clonedplanegeometry =
       dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
     // Cave: Statement below is negated!
     CPPUNIT_ASSERT_MESSAGE("Testing Clone(): ",
                            !((clonedplanegeometry.IsNull()) || (clonedplanegeometry->GetReferenceCount() != 1)));
     CPPUNIT_ASSERT_MESSAGE("Testing origin of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetOrigin(), origin, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in units) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height (in units) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing extent (in units) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of cloned version: ",
                            mitk::Equal(clonedplanegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of cloned version: right",
                            mitk::Equal(clonedplanegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of cloned version: bottom",
                            mitk::Equal(clonedplanegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of cloned version: normal",
                            mitk::Equal(clonedplanegeometry->GetAxisVector(2), normal, testEps));
 
     mappingTests2D(clonedplanegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   }
 
-  void TestSaggitalInitialization()
+  void TestSagittalInitialization()
   {
     mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
     mitk::PlaneGeometry::Pointer clonedplanegeometry = planegeometry->Clone();
 
     // Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Sagittal, zPosition = 0, frontside=true):
     planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Sagittal);
 
     mitk::Vector3D newright, newbottom, newnormal;
     mitk::ScalarType newthicknessInMM;
 
     newright = bottom;
     newthicknessInMM = widthInMM / width * 1.0; // extent in normal direction is 1;
     newnormal = right;
     newnormal.Normalize();
     newnormal *= newthicknessInMM;
     newbottom = normal;
     newbottom.Normalize();
     newbottom *= thicknessInMM;
 
-    CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of sagitally initialized version:",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of sagittally initialized version:",
                            mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0, testEps));
 
     // ok, corner was fine, so we can dare to believe the origin is ok.
     origin = planegeometry->GetOrigin();
 
-    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagitally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(0), height, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagitally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(1), 1, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagitally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
-    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagitally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), heightInMM, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagitally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagitally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps));
 
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagitally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagitally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagitally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), newnormal, testEps));
 
     mappingTests2D(planegeometry, height, 1, heightInMM, thicknessInMM, origin, newright, newbottom);
 
     // set origin back to the one of the axial slice:
     origin = clonedplanegeometry->GetOrigin();
     // Testing backside initialization: InitializeStandardPlane(clonedplanegeometry, planeorientation = Axial, zPosition
     // = 0, frontside=false, rotated=true):
     planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Axial, 0, false, true);
     mitk::Point3D backsideorigin;
     backsideorigin = origin + clonedplanegeometry->GetAxisVector(1); //+clonedplanegeometry->GetAxisVector(2);
 
     CPPUNIT_ASSERT_MESSAGE("Testing origin of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetOrigin(), backsideorigin, testEps));
 
     mitk::Point3D backsidecornerpoint0;
     backsidecornerpoint0 =
       cornerpoint0 + clonedplanegeometry->GetAxisVector(1); //+clonedplanegeometry->GetAxisVector(2);
-    CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of sagitally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of sagittally initialized version: ",
                            mitk::Equal(planegeometry->GetCornerPoint(0), backsidecornerpoint0, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of backsidedly, axially initialized version "
                            "(should be same as in mm due to unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of backsidedly, axially initialized version "
                            "(should be same as in mm due to unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of backsidedly, axially initialized version "
                            "(should be same as in mm due to unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), -bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of backsidedly, axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps)); // T22254: Flipped sign
 
     mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, backsideorigin, right, -bottom);
   }
 
-  void TestFrontalInitialization()
+  void TestCoronalInitialization()
   {
     mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
 
     mitk::PlaneGeometry::Pointer clonedplanegeometry =
       dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
     //--------
 
     mitk::Vector3D newright, newbottom, newnormal;
     mitk::ScalarType newthicknessInMM;
 
-    // Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Frontal, zPosition = 0, frontside=true)
-    planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Frontal);
+    // Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Coronal, zPosition = 0, frontside=true)
+    planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Coronal);
     newright = right;
     newbottom = normal;
     newbottom.Normalize();
     newbottom *= thicknessInMM;
     newthicknessInMM = heightInMM / height * 1.0 /*extent in normal direction is 1*/;
     newnormal = -bottom;
     newnormal.Normalize();
     newnormal *= newthicknessInMM;
 
-    CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0, testEps));
 
     // ok, corner was fine, so we can dare to believe the origin is ok.
     origin = planegeometry->GetOrigin();
 
-    CPPUNIT_ASSERT_MESSAGE("Testing width (in units) of frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing width (in units) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing height (in units) of frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing height (in units) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(1), 1, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing thickness (in units) of frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing thickness (in units) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
-    CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps));
 
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), -newnormal, testEps)); // T22254: Flipped sign
 
     mappingTests2D(planegeometry, width, 1, widthInMM, thicknessInMM, origin, newright, newbottom);
 
     // Changing plane to in-plane unit spacing using SetSizeInUnits:
     planegeometry->SetSizeInUnits(planegeometry->GetExtentInMM(0), planegeometry->GetExtentInMM(1));
 
-    CPPUNIT_ASSERT_MESSAGE("Testing origin of unit spaced, frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing origin of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(1), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps));
 
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), -newnormal, testEps)); // T22254: Flipped sign
 
     mappingTests2D(planegeometry, widthInMM, thicknessInMM, widthInMM, thicknessInMM, origin, newright, newbottom);
 
     // Changing plane to unit spacing also in normal direction using SetExtentInMM(2, 1.0):
     planegeometry->SetExtentInMM(2, 1.0);
     newnormal.Normalize();
 
-    CPPUNIT_ASSERT_MESSAGE("Testing origin of unit spaced, frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing origin of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(1), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in units) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE(
-      "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
+      "Testing width, height and thickness (in mm) of unit spaced, coronally initialized version: ",
       mitk::Equal(planegeometry->GetExtentInMM(2), 1.0, testEps));
 
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
-    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
+    CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, coronally initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), -newnormal, testEps)); // T22254: Flipped sign
     mappingTests2D(planegeometry, widthInMM, thicknessInMM, widthInMM, thicknessInMM, origin, newright, newbottom);
   }
 
   void TestAxialInitialization()
   {
     mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
 
     // Clone, move, rotate and test for 'IsParallel' and 'IsOnPlane'
     mitk::PlaneGeometry::Pointer clonedplanegeometry =
       dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
 
     CPPUNIT_ASSERT_MESSAGE("Testing Clone(): ",
                            !((clonedplanegeometry.IsNull()) || (clonedplanegeometry->GetReferenceCount() != 1)));
 
     std::cout << "Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Axial, zPosition = 0, "
                  "frontside=true): "
               << std::endl;
     planegeometry->InitializeStandardPlane(clonedplanegeometry);
 
     CPPUNIT_ASSERT_MESSAGE("Testing origin of axially initialized version: ",
                            mitk::Equal(planegeometry->GetOrigin(), origin));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of axially initialized version: ",
                            mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in units) of axially initialized version (should be same as in mm due to "
                            "unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(0), width, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height (in units) of axially initialized version (should be same as in mm due to "
                            "unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(1), height, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness (in units) of axially initialized version (should be same as in mm due "
                            "to unit spacing, except for thickness, which is always 1): ",
                            mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing height  (in mm) of axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of axially initialized version: ",
                            mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
 
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
     CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of axially initialized version: ",
                            mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
 
     mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
   }
 
   void TestPlaneComparison()
   {
     // Clone, move, rotate and test for 'IsParallel' and 'IsOnPlane'
     mitk::PlaneGeometry::Pointer clonedplanegeometry2 =
       dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
 
     CPPUNIT_ASSERT_MESSAGE("Testing Clone(): ",
                            !((clonedplanegeometry2.IsNull()) || (clonedplanegeometry2->GetReferenceCount() != 1)));
     CPPUNIT_ASSERT_MESSAGE("Testing wheter original and clone are at the same position",
                            clonedplanegeometry2->IsOnPlane(planegeometry.GetPointer()));
     CPPUNIT_ASSERT_MESSAGE(" Asserting that origin is on the plane cloned plane:",
                            clonedplanegeometry2->IsOnPlane(origin));
 
     mitk::VnlVector newaxis(3);
     mitk::FillVector3D(newaxis, 1.0, 1.0, 1.0);
     newaxis.normalize();
     vnl_quaternion<mitk::ScalarType> rotation2(newaxis, 0.0);
 
     mitk::Vector3D clonednormal = clonedplanegeometry2->GetNormal();
     mitk::Point3D clonedorigin = clonedplanegeometry2->GetOrigin();
 
     auto planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), 180.0);
 
     clonedplanegeometry2->ExecuteOperation(planerot);
     CPPUNIT_ASSERT_MESSAGE(" Asserting that a flipped plane is still on the original plane: ",
                            clonedplanegeometry2->IsOnPlane(planegeometry.GetPointer()));
 
     clonedorigin += clonednormal;
     clonedplanegeometry2->SetOrigin(clonedorigin);
 
     CPPUNIT_ASSERT_MESSAGE("Testing if the translated (cloned, flipped) plane is parallel to its origin plane: ",
                            clonedplanegeometry2->IsParallel(planegeometry));
     delete planerot;
 
     planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), 0.5);
     clonedplanegeometry2->ExecuteOperation(planerot);
 
     CPPUNIT_ASSERT_MESSAGE("Testing if a non-paralell plane gets recognized as not paralell  [rotation +0.5 degree] : ",
                            !clonedplanegeometry2->IsParallel(planegeometry));
     delete planerot;
 
     planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), -1.0);
     clonedplanegeometry2->ExecuteOperation(planerot);
 
     CPPUNIT_ASSERT_MESSAGE("Testing if a non-paralell plane gets recognized as not paralell  [rotation -0.5 degree] : ",
                            !clonedplanegeometry2->IsParallel(planegeometry));
     delete planerot;
 
     planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), 360.5);
     clonedplanegeometry2->ExecuteOperation(planerot);
 
     CPPUNIT_ASSERT_MESSAGE("Testing if a non-paralell plane gets recognized as paralell  [rotation 360 degree] : ",
                            clonedplanegeometry2->IsParallel(planegeometry));
   }
 
 private:
   // helper Methods for the Tests
 
   mitk::PlaneGeometry::Pointer createPlaneGeometry()
   {
     mitk::Vector3D mySpacing;
     mySpacing[0] = 31;
     mySpacing[1] = 0.1;
     mySpacing[2] = 5.4;
     mitk::Point3D myOrigin;
     myOrigin[0] = 8;
     myOrigin[1] = 9;
     myOrigin[2] = 10;
     mitk::AffineTransform3D::Pointer myTransform = mitk::AffineTransform3D::New();
     itk::Matrix<mitk::ScalarType, 3, 3> transMatrix;
     transMatrix.Fill(0);
     transMatrix[0][0] = 1;
     transMatrix[1][1] = 2;
     transMatrix[2][2] = 4;
 
     myTransform->SetMatrix(transMatrix);
 
     mitk::PlaneGeometry::Pointer geometry2D = mitk::PlaneGeometry::New();
     geometry2D->SetIndexToWorldTransform(myTransform);
     geometry2D->SetSpacing(mySpacing);
     geometry2D->SetOrigin(myOrigin);
     return geometry2D;
   }
 
   bool compareMatrix(itk::Matrix<mitk::ScalarType, 3, 3> left, itk::Matrix<mitk::ScalarType, 3, 3> right)
   {
     bool equal = true;
     for (int i = 0; i < 3; ++i)
       for (int j = 0; j < 3; ++j)
         equal &= mitk::Equal(left[i][j], right[i][j]);
     return equal;
   }
 
   /**
    * This function tests for correct mapping and is called several times from other tests
    **/
   void mappingTests2D(const mitk::PlaneGeometry *planegeometry,
                       const mitk::ScalarType &width,
                       const mitk::ScalarType &height,
                       const mitk::ScalarType &widthInMM,
                       const mitk::ScalarType &heightInMM,
                       const mitk::Point3D &origin,
                       const mitk::Vector3D &right,
                       const mitk::Vector3D &bottom)
   {
     std::cout << "Testing mapping Map(pt2d_mm(x=widthInMM/2.3,y=heightInMM/2.5), pt3d_mm) and compare with expected: ";
     mitk::Point2D pt2d_mm;
     mitk::Point3D pt3d_mm, expected_pt3d_mm;
     pt2d_mm[0] = widthInMM / 2.3;
     pt2d_mm[1] = heightInMM / 2.5;
     expected_pt3d_mm = origin + right * (pt2d_mm[0] / right.GetNorm()) + bottom * (pt2d_mm[1] / bottom.GetNorm());
     planegeometry->Map(pt2d_mm, pt3d_mm);
     CPPUNIT_ASSERT_MESSAGE(
       "Testing mapping Map(pt2d_mm(x=widthInMM/2.3,y=heightInMM/2.5), pt3d_mm) and compare with expected",
       mitk::Equal(pt3d_mm, expected_pt3d_mm, testEps));
 
     std::cout << "Testing mapping Map(pt3d_mm, pt2d_mm) and compare with expected: ";
     mitk::Point2D testpt2d_mm;
     planegeometry->Map(pt3d_mm, testpt2d_mm);
     std::cout << std::setprecision(12) << "Expected pt2d_mm " << pt2d_mm << std::endl;
     std::cout << std::setprecision(12) << "Result testpt2d_mm " << testpt2d_mm << std::endl;
     std::cout << std::setprecision(12) << "10*mitk::eps " << 10 * mitk::eps << std::endl;
     // This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
     CPPUNIT_ASSERT_MESSAGE("Testing mapping Map(pt3d_mm, pt2d_mm) and compare with expected",
                            mitk::Equal(pt2d_mm, testpt2d_mm, 10 * mitk::eps));
 
     std::cout << "Testing IndexToWorld(pt2d_units, pt2d_mm) and compare with expected: ";
     mitk::Point2D pt2d_units;
     pt2d_units[0] = width / 2.0;
     pt2d_units[1] = height / 2.0;
     pt2d_mm[0] = widthInMM / 2.0;
     pt2d_mm[1] = heightInMM / 2.0;
     planegeometry->IndexToWorld(pt2d_units, testpt2d_mm);
     std::cout << std::setprecision(12) << "Expected pt2d_mm " << pt2d_mm << std::endl;
     std::cout << std::setprecision(12) << "Result testpt2d_mm " << testpt2d_mm << std::endl;
     std::cout << std::setprecision(12) << "10*mitk::eps " << 10 * mitk::eps << std::endl;
     // This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
     CPPUNIT_ASSERT_MESSAGE("Testing IndexToWorld(pt2d_units, pt2d_mm) and compare with expected: ",
                            mitk::Equal(pt2d_mm, testpt2d_mm, 10 * mitk::eps));
 
     std::cout << "Testing WorldToIndex(pt2d_mm, pt2d_units) and compare with expected: ";
     mitk::Point2D testpt2d_units;
     planegeometry->WorldToIndex(pt2d_mm, testpt2d_units);
 
     std::cout << std::setprecision(12) << "Expected pt2d_units " << pt2d_units << std::endl;
     std::cout << std::setprecision(12) << "Result testpt2d_units " << testpt2d_units << std::endl;
     std::cout << std::setprecision(12) << "10*mitk::eps " << 10 * mitk::eps << std::endl;
     // This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
     CPPUNIT_ASSERT_MESSAGE("Testing WorldToIndex(pt2d_mm, pt2d_units) and compare with expected:",
                            mitk::Equal(pt2d_units, testpt2d_units, 10 * mitk::eps));
   }
 };
 MITK_TEST_SUITE_REGISTRATION(mitkPlaneGeometry)
diff --git a/Modules/Core/test/mitkPlanePositionManagerTest.cpp b/Modules/Core/test/mitkPlanePositionManagerTest.cpp
index dbb23f8049..98c49de80a 100644
--- a/Modules/Core/test/mitkPlanePositionManagerTest.cpp
+++ b/Modules/Core/test/mitkPlanePositionManagerTest.cpp
@@ -1,272 +1,272 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #include "mitkBaseProperty.h"
 #include "mitkDataNode.h"
 #include "mitkGeometry3D.h"
 #include "mitkImage.h"
 #include "mitkInteractionConst.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlanePositionManager.h"
 #include "mitkRotationOperation.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkStandaloneDataStorage.h"
 #include "mitkStringProperty.h"
 #include "mitkSurface.h"
 #include "mitkTestingMacros.h"
 #include "usGetModuleContext.h"
 #include "usModuleContext.h"
 #include "usServiceReference.h"
 #include "vnl/vnl_vector.h"
 
 std::vector<mitk::PlaneGeometry::Pointer> m_Geometries;
 std::vector<unsigned int> m_SliceIndices;
 
 mitk::PlanePositionManagerService *m_Service;
 
 int SetUpBeforeTest()
 {
   // Getting Service
   us::ServiceReference<mitk::PlanePositionManagerService> serviceRef =
     us::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
   m_Service = us::GetModuleContext()->GetService(serviceRef);
 
   if (m_Service == nullptr)
     return EXIT_FAILURE;
 
   // Creating different Geometries
   m_Geometries.reserve(100);
   mitk::PlaneGeometry::PlaneOrientation views[] = {
-    mitk::PlaneGeometry::Axial, mitk::PlaneGeometry::Sagittal, mitk::PlaneGeometry::Frontal};
+    mitk::PlaneGeometry::Axial, mitk::PlaneGeometry::Sagittal, mitk::PlaneGeometry::Coronal};
   for (unsigned int i = 0; i < 100; ++i)
   {
     mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
 
     mitk::ScalarType width = 256 + (0.01 * i);
     mitk::ScalarType height = 256 + (0.002 * i);
 
     mitk::Vector3D right;
     mitk::Vector3D down;
     right[0] = 1;
     right[1] = i;
     right[2] = 0.5;
     down[0] = i * 0.02;
     down[1] = 1;
     down[2] = i * 0.03;
 
     mitk::Vector3D spacing;
     mitk::FillVector3D(spacing, 1.0 * 0.02 * i, 1.0 * 0.15 * i, 1.0);
 
     mitk::Vector3D rightVector;
     mitk::FillVector3D(rightVector, 0.02 * (i + 1), 0 + (0.05 * i), 1.0);
 
     mitk::Vector3D downVector;
     mitk::FillVector3D(downVector, 1, 3 - 0.01 * i, 0.0345 * i);
 
     vnl_vector<mitk::ScalarType> normal = vnl_cross_3d(rightVector.GetVnlVector(), downVector.GetVnlVector());
     normal.normalize();
     normal *= 1.5;
 
     mitk::Vector3D origin;
     origin.Fill(1);
     origin[0] = 12 + 0.03 * i;
 
     mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
     mitk::Matrix3D matrix;
     matrix.GetVnlMatrix().set_column(0, rightVector.GetVnlVector());
     matrix.GetVnlMatrix().set_column(1, downVector.GetVnlVector());
     matrix.GetVnlMatrix().set_column(2, normal);
     transform->SetMatrix(matrix);
     transform->SetOffset(origin);
 
     plane->InitializeStandardPlane(width, height, transform, views[i % 3], i, true, false);
 
     m_Geometries.push_back(plane);
   }
 
   return EXIT_SUCCESS;
 }
 
 int testAddPlanePosition()
 {
   MITK_TEST_OUTPUT(<< "Starting Test: ######### A d d P l a n e P o s i t i o n #########");
 
   MITK_TEST_CONDITION(m_Service != nullptr, "Testing getting of PlanePositionManagerService");
 
   unsigned int currentID(m_Service->AddNewPlanePosition(m_Geometries.at(0), 0));
 
   bool error = ((m_Service->GetNumberOfPlanePositions() != 1) || (currentID != 0));
 
   if (error)
   {
     MITK_TEST_CONDITION(m_Service->GetNumberOfPlanePositions() == 1, "Checking for correct number of planepositions");
     MITK_TEST_CONDITION(currentID == 0, "Testing for correct ID");
     return EXIT_FAILURE;
   }
 
   // Adding new planes
   for (unsigned int i = 1; i < m_Geometries.size(); ++i)
   {
     unsigned int newID = m_Service->AddNewPlanePosition(m_Geometries.at(i), i);
     error = ((m_Service->GetNumberOfPlanePositions() != i + 1) || (newID != (currentID + 1)));
 
     if (error)
     {
       MITK_TEST_CONDITION(m_Service->GetNumberOfPlanePositions() == i + 1,
                           "Checking for correct number of planepositions");
       MITK_TEST_CONDITION(newID == (currentID + 1), "Testing for correct ID");
       MITK_TEST_OUTPUT(<< "New: " << newID << " Last: " << currentID);
       return EXIT_FAILURE;
     }
     currentID = newID;
   }
 
   unsigned int numberOfPlanePos = m_Service->GetNumberOfPlanePositions();
 
   // Adding existing planes -> nothing should change
   for (unsigned int i = 0; i < (m_Geometries.size() - 1) * 0.5; ++i)
   {
     unsigned int newID = m_Service->AddNewPlanePosition(m_Geometries.at(i * 2), i * 2);
     error = ((m_Service->GetNumberOfPlanePositions() != numberOfPlanePos) || (newID != i * 2));
     if (error)
     {
       MITK_TEST_CONDITION(m_Service->GetNumberOfPlanePositions() == numberOfPlanePos,
                           "Checking for correct number of planepositions");
       MITK_TEST_CONDITION(newID == i * 2, "Testing for correct ID");
       return EXIT_FAILURE;
     }
   }
 
   return EXIT_SUCCESS;
 }
 
 int testGetPlanePosition()
 {
   bool error(true);
 
   MITK_TEST_OUTPUT(<< "Starting Test: ######### G e t P l a n e P o s i t i o n #########");
 
   // Testing for existing planepositions
   for (unsigned int i = 0; i < m_Geometries.size(); ++i)
   {
     auto plane = m_Geometries.at(i);
     auto op = m_Service->GetPlanePosition(i);
     error =
       (!mitk::Equal(op->GetHeight(), plane->GetExtent(1)) || !mitk::Equal(op->GetWidth(), plane->GetExtent(0)) ||
        !mitk::Equal(op->GetSpacing(), plane->GetSpacing()) ||
        !mitk::Equal(op->GetTransform()->GetOffset(), plane->GetIndexToWorldTransform()->GetOffset()) ||
        !mitk::Equal(op->GetDirectionVector().GetVnlVector(),
                     plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).normalize().as_ref()) ||
        !mitk::MatrixEqualElementWise(op->GetTransform()->GetMatrix(), plane->GetIndexToWorldTransform()->GetMatrix()));
 
     if (error)
     {
       MITK_TEST_OUTPUT(<< "Iteration: " << i)
       MITK_TEST_CONDITION(
         mitk::Equal(op->GetHeight(), plane->GetExtent(1)) && mitk::Equal(op->GetWidth(), plane->GetExtent(0)),
         "Checking for correct extent");
       MITK_TEST_CONDITION(mitk::Equal(op->GetSpacing(), plane->GetSpacing()), "Checking for correct spacing");
       MITK_TEST_CONDITION(mitk::Equal(op->GetTransform()->GetOffset(), plane->GetIndexToWorldTransform()->GetOffset()),
                           "Checking for correct offset");
       MITK_INFO << "Op: " << op->GetDirectionVector()
                 << " plane: " << plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2) << "\n";
       MITK_TEST_CONDITION(mitk::Equal(op->GetDirectionVector().GetVnlVector(),
                                       plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).as_ref()),
                           "Checking for correct direction");
       MITK_TEST_CONDITION(
         mitk::MatrixEqualElementWise(op->GetTransform()->GetMatrix(), plane->GetIndexToWorldTransform()->GetMatrix()),
         "Checking for correct matrix");
       return EXIT_FAILURE;
     }
   }
 
   // Testing for not existing planepositions
   error = (m_Service->GetPlanePosition(100000000) != nullptr || m_Service->GetPlanePosition(-1) != nullptr);
 
   if (error)
   {
     MITK_TEST_CONDITION(m_Service->GetPlanePosition(100000000) == nullptr, "Trying to get non existing pos");
     MITK_TEST_CONDITION(m_Service->GetPlanePosition(-1) == nullptr, "Trying to get non existing pos");
     return EXIT_FAILURE;
   }
 
   return EXIT_SUCCESS;
 }
 
 int testRemovePlanePosition()
 {
   MITK_TEST_OUTPUT(<< "Starting Test: ######### R e m o v e P l a n e P o s i t i o n #########");
   unsigned int size = m_Service->GetNumberOfPlanePositions();
 
   // Testing for invalid IDs
   bool removed = m_Service->RemovePlanePosition(-1);
   removed = m_Service->RemovePlanePosition(1000000);
   unsigned int size2 = m_Service->GetNumberOfPlanePositions();
 
   if (removed)
   {
     MITK_TEST_CONDITION(removed == false, "Testing remove not existing planepositions");
     MITK_TEST_CONDITION(size == size2, "Testing remove not existing planepositions");
     return EXIT_FAILURE;
   }
 
   // Testing for valid IDs
   for (unsigned int i = 0; i < m_Geometries.size() * 0.5; i++)
   {
     removed = m_Service->RemovePlanePosition(i);
     unsigned int size2 = m_Service->GetNumberOfPlanePositions();
     removed = (size2 == (size - (i + 1)));
     if (!removed)
     {
       MITK_TEST_CONDITION(removed == true, "Testing remove existing planepositions");
       MITK_TEST_CONDITION(size == (size - i + 1), "Testing remove existing planepositions");
       return EXIT_FAILURE;
     }
   }
 
   return EXIT_SUCCESS;
 }
 
 int testRemoveAll()
 {
   MITK_TEST_OUTPUT(<< "Starting Test: ######### R e m o v e A l l #########");
 
   unsigned int numPos = m_Service->GetNumberOfPlanePositions();
   MITK_INFO << numPos;
 
   m_Service->RemoveAllPlanePositions();
 
   bool error(true);
 
   error = (m_Service->GetNumberOfPlanePositions() != 0 || m_Service->GetPlanePosition(60) != nullptr);
 
   if (error)
   {
     MITK_TEST_CONDITION(m_Service->GetNumberOfPlanePositions() == 0, "Testing remove all pos");
     MITK_TEST_CONDITION(m_Service->GetPlanePosition(60) == nullptr, "Testing remove all pos");
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
 
 int mitkPlanePositionManagerTest(int, char *[])
 {
   MITK_TEST_BEGIN("PlanePositionManager");
 
   SetUpBeforeTest();
   int result;
   MITK_TEST_CONDITION_REQUIRED((result = testAddPlanePosition()) == EXIT_SUCCESS, "");
   MITK_TEST_CONDITION_REQUIRED((result = testGetPlanePosition()) == EXIT_SUCCESS, "");
   MITK_TEST_CONDITION_REQUIRED((result = testRemovePlanePosition()) == EXIT_SUCCESS, "");
   MITK_TEST_CONDITION_REQUIRED((result = testRemoveAll()) == EXIT_SUCCESS, "");
 
   MITK_TEST_END();
 }
diff --git a/Modules/Core/test/mitkRotatedSlice4DTest.cpp b/Modules/Core/test/mitkRotatedSlice4DTest.cpp
index 474bf3f5dd..22da8a8bfa 100644
--- a/Modules/Core/test/mitkRotatedSlice4DTest.cpp
+++ b/Modules/Core/test/mitkRotatedSlice4DTest.cpp
@@ -1,84 +1,84 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkExtractSliceFilter.h"
 #include "mitkIOUtil.h"
 #include "mitkImagePixelReadAccessor.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkInteractionConst.h"
 #include "mitkRotationOperation.h"
 #include "mitkTestingMacros.h"
 #include <ctime>
 
 /*
 * The mitkRotatedSlice4DTest loads a 4D image and extracts a specifically rotated slice in each time step's volume.
 */
 int mitkRotatedSlice4DTest(int, char *argv[])
 {
   MITK_TEST_BEGIN("mitkRotatedSlice4DTest");
 
   std::string filename = argv[1];
 
   // load 4D image
   mitk::Image::Pointer image4D = mitk::IOUtil::Load<mitk::Image>(filename);
   // check inputs
   if (image4D.IsNull())
   {
     MITK_INFO << "Could not load the file";
     return false;
   }
 
   auto numTimeSteps = std::min(2, static_cast<int>(image4D->GetTimeSteps()));
 
   for (int ts = 0; ts < numTimeSteps; ++ts)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(image4D);
     timeSelector->SetTimeNr(ts);
     timeSelector->Update();
     mitk::Image::Pointer image3D = timeSelector->GetOutput();
 
     int sliceNumber = std::min(5, static_cast<int>(image3D->GetSlicedGeometry()->GetSlices()));
 
     mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
-    plane->InitializeStandardPlane(image3D->GetGeometry(), mitk::PlaneGeometry::Frontal, sliceNumber, true, false);
+    plane->InitializeStandardPlane(image3D->GetGeometry(), mitk::PlaneGeometry::Coronal, sliceNumber, true, false);
 
     // rotate about an arbitrary point and axis...
     float angle = 30;
     mitk::Point3D point;
     point.Fill(sliceNumber);
     mitk::Vector3D rotationAxis;
     rotationAxis[0] = 1;
     rotationAxis[1] = 2;
     rotationAxis[2] = 3;
     rotationAxis.Normalize();
 
     // Create Rotation Operation
     auto *op = new mitk::RotationOperation(mitk::OpROTATE, point, rotationAxis, angle);
     plane->ExecuteOperation(op);
     delete op;
 
     // Now extract
     mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New();
     extractor->SetInput(image3D);
     extractor->SetWorldGeometry(plane);
     extractor->Update();
     mitk::Image::Pointer extractedPlane;
     extractedPlane = extractor->GetOutput();
 
     std::stringstream ss;
     ss << " : Valid slice in timestep " << ts;
 
     MITK_TEST_CONDITION_REQUIRED(extractedPlane.IsNotNull(), ss.str().c_str());
   }
   MITK_TEST_END();
 }
diff --git a/Modules/Core/test/mitkSliceNavigationControllerTest.cpp b/Modules/Core/test/mitkSliceNavigationControllerTest.cpp
index 59950d9697..232eeb6a33 100644
--- a/Modules/Core/test/mitkSliceNavigationControllerTest.cpp
+++ b/Modules/Core/test/mitkSliceNavigationControllerTest.cpp
@@ -1,205 +1,205 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkGeometry3D.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkSlicedGeometry3D.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkArbitraryTimeGeometry.h>
 
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 // T22254
 
 class mitkSliceNavigationControllerTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkSliceNavigationControllerTestSuite);
   CPPUNIT_TEST(validateAxialViewDirection);
   CPPUNIT_TEST(validateCoronalViewDirection);
   CPPUNIT_TEST(validateSagittalViewDirection);
   CPPUNIT_TEST(GetSelectedTimePoint);
   CPPUNIT_TEST_SUITE_END();
 
   mitk::Geometry3D::Pointer m_Geometry3D;
   mitk::ArbitraryTimeGeometry::Pointer m_TimeGeometry;
 
 public:
   void setUp() override
   {
     mitk::Point3D origin;
     mitk::FillVector3D(origin, 10.0, 20.0, 30.0);
 
     mitk::Vector3D firstAxisVector;
     mitk::FillVector3D(firstAxisVector, 100.0, 0.0, 0.0);
 
     mitk::Vector3D secondAxisVector;
     mitk::FillVector3D(secondAxisVector, 0.0, 50.0, 0.0);
 
     mitk::Vector3D spacing;
     mitk::FillVector3D(spacing, 1.0, 1.0, 2.0);
 
     auto planeGeometry = mitk::PlaneGeometry::New();
     planeGeometry->InitializeStandardPlane(firstAxisVector, secondAxisVector, &spacing);
     planeGeometry->SetOrigin(origin);
 
     unsigned int numberOfSlices = 100U;
 
     auto slicedGeometry3D = mitk::SlicedGeometry3D::New();
     slicedGeometry3D->InitializeEvenlySpaced(planeGeometry, numberOfSlices);
 
     m_Geometry3D = mitk::Geometry3D::New();
     m_Geometry3D->SetBounds(slicedGeometry3D->GetBounds());
     m_Geometry3D->SetIndexToWorldTransform(slicedGeometry3D->GetIndexToWorldTransform());
 
     m_TimeGeometry = mitk::ArbitraryTimeGeometry::New();
     m_TimeGeometry->AppendNewTimeStepClone(m_Geometry3D, 0.5, 10.);
     m_TimeGeometry->AppendNewTimeStepClone(m_Geometry3D, 10., 30.);
     m_TimeGeometry->AppendNewTimeStepClone(m_Geometry3D, 30., 50.);
     m_TimeGeometry->AppendNewTimeStepClone(m_Geometry3D, 50., 60.);
     m_TimeGeometry->Update();
   }
 
   void tearDown() override
   {
   }
 
   void validateAxialViewDirection()
   {
     auto sliceNavigationController = mitk::SliceNavigationController::New();
 
     sliceNavigationController->SetInputWorldGeometry3D(m_Geometry3D);
     sliceNavigationController->SetViewDirection(mitk::SliceNavigationController::Axial);
     sliceNavigationController->Update();
 
     mitk::Point3D origin;
     mitk::FillVector3D(origin, 10.0, 70.0, 229.0);
 
     mitk::Vector3D firstAxisVector;
     mitk::FillVector3D(firstAxisVector, 100.0, 0.0, 0.0);
 
     mitk::Vector3D secondAxisVector;
     mitk::FillVector3D(secondAxisVector, 0.0, -50.0, 0.0);
 
     mitk::Vector3D thirdAxisVector;
     mitk::FillVector3D(thirdAxisVector, 0.0, 0.0, -200.0);
 
     std::cout << "Axial view direction" << std::endl;
     CPPUNIT_ASSERT(this->validateGeometry(sliceNavigationController->GetCurrentGeometry3D(), origin, firstAxisVector, secondAxisVector, thirdAxisVector));
   }
 
   void validateCoronalViewDirection()
   {
     auto sliceNavigationController = mitk::SliceNavigationController::New();
 
     sliceNavigationController->SetInputWorldGeometry3D(m_Geometry3D);
-    sliceNavigationController->SetViewDirection(mitk::SliceNavigationController::Frontal);
+    sliceNavigationController->SetViewDirection(mitk::SliceNavigationController::Coronal);
     sliceNavigationController->Update();
 
     mitk::Point3D origin;
     mitk::FillVector3D(origin, 10.0, 69.5, 30.0);
 
     mitk::Vector3D firstAxisVector;
     mitk::FillVector3D(firstAxisVector, 100.0, 0.0, 0.0);
 
     mitk::Vector3D secondAxisVector;
     mitk::FillVector3D(secondAxisVector, 0.0, 0.0, 200.0);
 
     mitk::Vector3D thirdAxisVector;
     mitk::FillVector3D(thirdAxisVector, 0.0, -50.0, 0.0);
 
     std::cout << "Coronal view direction" << std::endl;
     CPPUNIT_ASSERT(this->validateGeometry(sliceNavigationController->GetCurrentGeometry3D(), origin, firstAxisVector, secondAxisVector, thirdAxisVector));
   }
 
   void validateSagittalViewDirection()
   {
     auto sliceNavigationController = mitk::SliceNavigationController::New();
 
     sliceNavigationController->SetInputWorldGeometry3D(m_Geometry3D);
     sliceNavigationController->SetViewDirection(mitk::SliceNavigationController::Sagittal);
     sliceNavigationController->Update();
 
     mitk::Point3D origin;
     mitk::FillVector3D(origin, 10.5, 20.0, 30.0);
 
     mitk::Vector3D firstAxisVector;
     mitk::FillVector3D(firstAxisVector, 0.0, 50.0, 0.0);
 
     mitk::Vector3D secondAxisVector;
     mitk::FillVector3D(secondAxisVector, 0.0, 0.0, 200.0);
 
     mitk::Vector3D thirdAxisVector;
     mitk::FillVector3D(thirdAxisVector, 100.0, 0.0, 0.0);
 
     std::cout << "Sagittal view direction" << std::endl;
     CPPUNIT_ASSERT(this->validateGeometry(sliceNavigationController->GetCurrentGeometry3D(), origin, firstAxisVector, secondAxisVector, thirdAxisVector));
   }
 
   void GetSelectedTimePoint()
   {
     auto sliceNavigationController = mitk::SliceNavigationController::New();
 
     CPPUNIT_ASSERT(sliceNavigationController->GetSelectedTimePoint() == 0.);
 
     sliceNavigationController->SetInputWorldTimeGeometry(m_TimeGeometry);
     sliceNavigationController->SetViewDirection(mitk::SliceNavigationController::Sagittal);
     sliceNavigationController->Update();
 
     CPPUNIT_ASSERT(sliceNavigationController->GetSelectedTimeStep() == 0);
     CPPUNIT_ASSERT(sliceNavigationController->GetSelectedTimePoint() == 0.5);
 
     sliceNavigationController->GetTime()->SetPos(2);
     CPPUNIT_ASSERT(sliceNavigationController->GetSelectedTimeStep() == 2);
     CPPUNIT_ASSERT(sliceNavigationController->GetSelectedTimePoint() == 30.0);
 
     auto sliceNavigationController2 = mitk::SliceNavigationController::New();
 
     sliceNavigationController2->SetInputWorldGeometry3D(m_Geometry3D);
     sliceNavigationController2->SetViewDirection(mitk::SliceNavigationController::Sagittal);
     sliceNavigationController2->Update();
 
     CPPUNIT_ASSERT(sliceNavigationController2->GetSelectedTimeStep() == 0);
     CPPUNIT_ASSERT(sliceNavigationController2->GetSelectedTimePoint() == 0.0);
   }
 
 private:
   bool validateGeometry(mitk::BaseGeometry::ConstPointer geometry, const mitk::Point3D &origin, const mitk::Vector3D &firstAxisVector, const mitk::Vector3D &secondAxisVector, const mitk::Vector3D &thirdAxisVector)
   {
     bool result = true;
 
     std::cout << "  Origin" << std::endl;
 
     if (!mitk::Equal(geometry->GetOrigin(), origin, mitk::eps, true))
       result = false;
 
     std::cout << "  First axis vector" << std::endl;
 
     if (!mitk::Equal(geometry->GetAxisVector(0), firstAxisVector, mitk::eps, true))
       result = false;
 
     std::cout << "  Second axis vector" << std::endl;
 
     if (!mitk::Equal(geometry->GetAxisVector(1), secondAxisVector, mitk::eps, true))
       result = false;
 
     std::cout << "  Third axis vector" << std::endl;
 
     if (!mitk::Equal(geometry->GetAxisVector(2), thirdAxisVector, mitk::eps, true))
       result = false;
 
     return result;
   }
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkSliceNavigationController)
diff --git a/Modules/CppMicroServices/cmake/usMacroCreateModule.cmake b/Modules/CppMicroServices/cmake/usMacroCreateModule.cmake
index 31e6d48176..d27622bde8 100644
--- a/Modules/CppMicroServices/cmake/usMacroCreateModule.cmake
+++ b/Modules/CppMicroServices/cmake/usMacroCreateModule.cmake
@@ -1,243 +1,247 @@
 # For internal use only
 
 macro(usMacroCreateModule _project_name)
 
 project(${_project_name})
 
 cmake_parse_arguments(${PROJECT_NAME}
   "SKIP_EXAMPLES;SKIP_INIT"
   "VERSION;TARGET"
-  "DEPENDS;INTERNAL_INCLUDE_DIRS;LINK_LIBRARIES;SOURCES;PRIVATE_HEADERS;PUBLIC_HEADERS;RESOURCES;BINARY_RESOURCES"
+  "DEPENDS;INTERNAL_INCLUDE_DIRS;LINK_LIBRARIES;PRIVATE_LINK_LIBRARIES;SOURCES;PRIVATE_HEADERS;PUBLIC_HEADERS;RESOURCES;BINARY_RESOURCES"
   ${ARGN}
 )
 
 if(NOT ${PROJECT_NAME}_VERSION MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+$")
   message(SEND_ERROR "VERSION argument invalid: ${${PROJECT_NAME}_VERSION}")
 endif()
 
 string(REPLACE "." ";" _version_numbers ${${PROJECT_NAME}_VERSION})
 list(GET _version_numbers 0 ${PROJECT_NAME}_MAJOR_VERSION)
 list(GET _version_numbers 1 ${PROJECT_NAME}_MINOR_VERSION)
 list(GET _version_numbers 2 ${PROJECT_NAME}_PATCH_VERSION)
 
 if(NOT ${PROJECT_NAME}_TARGET)
   set(${PROJECT_NAME}_TARGET us${PROJECT_NAME})
 endif()
 set(PROJECT_TARGET ${${PROJECT_NAME}_TARGET})
 
 if(${PROJECT_NAME}_DEPENDS)
   find_package(CppMicroServices REQUIRED ${${PROJECT_NAME}_DEPENDS} QUIET
     HINTS ${CppMicroServices_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 endif()
 
 #-----------------------------------------------------------------------------
 # Include dirs and libraries
 #-----------------------------------------------------------------------------
 
 set(${PROJECT_NAME}_INCLUDE_DIRS
   ${CMAKE_CURRENT_SOURCE_DIR}/include
   ${CMAKE_CURRENT_BINARY_DIR}/include
 )
 
 configure_file(${CppMicroServices_SOURCE_DIR}/cmake/usExport.h.in
                ${CMAKE_CURRENT_BINARY_DIR}/include/us${PROJECT_NAME}Export.h)
 list(APPEND ${PROJECT_NAME}_PUBLIC_HEADERS
   ${CMAKE_CURRENT_BINARY_DIR}/include/us${PROJECT_NAME}Export.h)
 
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/include/us${PROJECT_NAME}Config.h.in)
   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/include/us${PROJECT_NAME}Config.h.in
                  ${CMAKE_CURRENT_BINARY_DIR}/include/us${PROJECT_NAME}Config.h)
   list(APPEND ${PROJECT_NAME}_PUBLIC_HEADERS
     ${CMAKE_CURRENT_BINARY_DIR}/include/us${PROJECT_NAME}Config.h)
 endif()
 
 set(_internal_include_dirs ${${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS})
 set(${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS )
 
 if(_internal_include_dirs)
   foreach(_internal_include_dir ${_internal_include_dirs})
     if(IS_ABSOLUTE "${_internal_include_dir}")
       list(APPEND ${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS ${_internal_include_dir})
     else()
       list(APPEND ${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/${_internal_include_dir})
     endif()
   endforeach()
 endif()
 
 
 if(CMAKE_VERSION VERSION_LESS 2.8.12)
   include_directories(
     ${US_INCLUDE_DIRS}
     ${${PROJECT_NAME}_INCLUDE_DIRS}
     ${${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS}
   )
 endif()
 
 #-----------------------------------------------------------------------------
 # Create library
 #-----------------------------------------------------------------------------
 
 # Generate the module init file
 if(NOT ${PROJECT_NAME}_SKIP_INIT)
   usFunctionGenerateModuleInit(${PROJECT_NAME}_SOURCES)
 endif()
 
 if(${PROJECT_NAME}_RESOURCES OR ${PROJECT_NAME}_BINARY_RESOURCES)
   usFunctionGetResourceSource(TARGET ${${PROJECT_NAME}_TARGET} OUT ${PROJECT_NAME}_SOURCES)
 endif()
 
 # Create the module library
 add_library(${${PROJECT_NAME}_TARGET} ${${PROJECT_NAME}_SOURCES}
             ${${PROJECT_NAME}_PRIVATE_HEADERS} ${${PROJECT_NAME}_PUBLIC_HEADERS})
 
 # Compile definitions
 set_property(TARGET ${${PROJECT_NAME}_TARGET} APPEND PROPERTY COMPILE_DEFINITIONS US_MODULE_NAME=${${PROJECT_NAME}_TARGET})
 set_property(TARGET ${${PROJECT_NAME}_TARGET} PROPERTY US_MODULE_NAME ${${PROJECT_NAME}_TARGET})
 set_property(TARGET ${${PROJECT_NAME}_TARGET} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/CppMicroServices")
 if(NOT US_BUILD_SHARED_LIBS)
   set_property(TARGET ${${PROJECT_NAME}_TARGET} APPEND PROPERTY COMPILE_DEFINITIONS US_STATIC_MODULE)
 endif()
 
 # Link flags
 if(${PROJECT_NAME}_LINK_FLAGS OR US_LINK_FLAGS)
   set_target_properties(${${PROJECT_NAME}_TARGET} PROPERTIES
     LINK_FLAGS "${US_LINK_FLAGS} ${${PROJECT_NAME}_LINK_FLAGS}"
   )
 endif()
 
 if(CMAKE_VERSION VERSION_GREATER 2.8.11.99)
   # Currently, public headers include private header files,
   # so the internal include dirs need to be in the public
   # include dir section. This needs to be fixed.
   target_include_directories(${${PROJECT_NAME}_TARGET}
     PUBLIC ${US_INCLUDE_DIRS} ${${PROJECT_NAME}_INCLUDE_DIRS}
     PUBLIC ${${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS}
    )
 endif()
 
 
 set_target_properties(${${PROJECT_NAME}_TARGET} PROPERTIES
   SOVERSION ${${PROJECT_NAME}_VERSION}
   PUBLIC_HEADER "${${PROJECT_NAME}_PUBLIC_HEADERS}"
   PRIVATE_HEADER "${${PROJECT_NAME}_PRIVATE_HEADERS}"
 )
 
 # Link additional libraries
 if(${PROJECT_NAME}_LINK_LIBRARIES OR US_LIBRARIES)
-  target_link_libraries(${${PROJECT_NAME}_TARGET} ${US_LIBRARIES} ${${PROJECT_NAME}_LINK_LIBRARIES})
+  target_link_libraries(${${PROJECT_NAME}_TARGET} PUBLIC ${US_LIBRARIES} ${${PROJECT_NAME}_LINK_LIBRARIES})
+endif()
+
+if(${PROJECT_NAME}_PRIVATE_LINK_LIBRARIES)
+  target_link_libraries(${${PROJECT_NAME}_TARGET} PRIVATE ${${PROJECT_NAME}_PRIVATE_LINK_LIBRARIES})
 endif()
 
 # Embed module resources
 
 if(${PROJECT_NAME}_RESOURCES OR US_LIBRARIES)
   usFunctionAddResources(TARGET ${${PROJECT_NAME}_TARGET}
                          WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/resources
                          FILES ${${PROJECT_NAME}_RESOURCES}
                          ZIP_ARCHIVES ${US_LIBRARIES}
                         )
 endif()
 if(${PROJECT_NAME}_BINARY_RESOURCES)
   usFunctionAddResources(TARGET ${${PROJECT_NAME}_TARGET}
                          WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/resources
                          FILES ${${PROJECT_NAME}_BINARY_RESOURCES}
                         )
 endif()
 usFunctionEmbedResources(TARGET ${${PROJECT_NAME}_TARGET})
 
 #-----------------------------------------------------------------------------
 # Install support
 #-----------------------------------------------------------------------------
 
 if(NOT US_NO_INSTALL)
   install(TARGETS ${${PROJECT_NAME}_TARGET}
           EXPORT us${PROJECT_NAME}Targets
           RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
           LIBRARY DESTINATION ${LIBRARY_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
           ARCHIVE DESTINATION ${ARCHIVE_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
           PUBLIC_HEADER DESTINATION ${HEADER_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT}
           PRIVATE_HEADER DESTINATION ${HEADER_INSTALL_DIR} ${US_SDK_INSTALL_COMPONENT})
 endif()
 
 #-----------------------------------------------------------------------------
 # US testing
 #-----------------------------------------------------------------------------
 
 if(US_BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
   add_subdirectory(test)
 endif()
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 if(US_BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/doc/snippets/CMakeLists.txt")
   # Compile source code snippets
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/doc/snippets)
 endif()
 
 #-----------------------------------------------------------------------------
 # Last configuration and install steps
 #-----------------------------------------------------------------------------
 
 # Version information
 configure_file(
   ${US_CMAKE_DIR}/usModuleConfigVersion.cmake.in
   ${CppMicroServices_BINARY_DIR}/us${PROJECT_NAME}ConfigVersion.cmake
   @ONLY
   )
 
 export(TARGETS ${${PROJECT_NAME}_TARGET} ${US_LIBRARIES}
        FILE ${CppMicroServices_BINARY_DIR}/us${PROJECT_NAME}Targets.cmake)
 if(NOT US_NO_INSTALL)
   install(EXPORT us${PROJECT_NAME}Targets
           FILE us${PROJECT_NAME}Targets.cmake
           DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR})
 endif()
 
 # Configure config file for the build tree
 
 set(PACKAGE_CONFIG_INCLUDE_DIR
   ${${PROJECT_NAME}_INCLUDE_DIRS}
   ${${PROJECT_NAME}_INTERNAL_INCLUDE_DIRS})
 set(PACKAGE_CONFIG_RUNTIME_LIBRARY_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 
 configure_file(
   ${US_CMAKE_DIR}/usModuleConfig.cmake.in
   ${CppMicroServices_BINARY_DIR}/us${PROJECT_NAME}Config.cmake
   @ONLY
   )
 
 # Configure config file for the install tree
 
 if(NOT US_NO_INSTALL)
   set(CONFIG_INCLUDE_DIR ${HEADER_INSTALL_DIR})
   set(CONFIG_RUNTIME_LIBRARY_DIR ${RUNTIME_INSTALL_DIR})
 
   configure_package_config_file(
     ${US_CMAKE_DIR}/usModuleConfig.cmake.in
     ${CppMicroServices_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/us${PROJECT_NAME}Config.cmake
     INSTALL_DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
     PATH_VARS CONFIG_INCLUDE_DIR CONFIG_RUNTIME_LIBRARY_DIR
     NO_SET_AND_CHECK_MACRO
     NO_CHECK_REQUIRED_COMPONENTS_MACRO
     )
 
   install(FILES ${CppMicroServices_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/us${PROJECT_NAME}Config.cmake
                 ${CppMicroServices_BINARY_DIR}/us${PROJECT_NAME}ConfigVersion.cmake
           DESTINATION ${AUXILIARY_CMAKE_INSTALL_DIR}
           ${US_SDK_INSTALL_COMPONENT})
 endif()
 
 #-----------------------------------------------------------------------------
 # Build the examples
 #-----------------------------------------------------------------------------
 
 if(US_BUILD_EXAMPLES AND NOT ${PROJECT_NAME}_SKIP_EXAMPLES AND
    EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/examples/CMakeLists.txt)
   set(CppMicroServices_DIR ${CppMicroServices_BINARY_DIR})
   add_subdirectory(examples)
 endif()
 
 endmacro()
diff --git a/Modules/CppMicroServices/core/CMakeLists.txt b/Modules/CppMicroServices/core/CMakeLists.txt
index 244fa9a635..e70785c45a 100644
--- a/Modules/CppMicroServices/core/CMakeLists.txt
+++ b/Modules/CppMicroServices/core/CMakeLists.txt
@@ -1,45 +1,46 @@
 # sources and headers
 include(${CMAKE_CURRENT_SOURCE_DIR}/src/CMakeLists.txt)
 include(${CMAKE_CURRENT_SOURCE_DIR}/include/CMakeLists.txt)
 
 set(_core_srcs )
 foreach(_src ${_srcs})
   list(APPEND _core_srcs ${CMAKE_CURRENT_SOURCE_DIR}/src/${_src})
 endforeach()
 
 set(_core_private_headers)
 foreach(_header ${_private_headers})
   list(APPEND _core_private_headers ${CMAKE_CURRENT_SOURCE_DIR}/src/${_header})
 endforeach()
 
 set(_core_public_headers )
 foreach(_header ${_public_headers})
   list(APPEND _core_public_headers ${CMAKE_CURRENT_SOURCE_DIR}/include/${_header})
 endforeach()
 
 # link libraries for the CppMicroServices lib
 set(_link_libraries )
 if(UNIX)
   list(APPEND _link_libraries dl)
 endif()
 
 # Configure the modules manifest.json file
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/manifest.json.in
                ${CMAKE_CURRENT_BINARY_DIR}/resources/manifest.json)
 
 usMacroCreateModule(Core
   SKIP_INIT # we initialize the module in usModuleRegistry.cpp ourselves
   VERSION "2.99.0"
   TARGET CppMicroServices
   INTERNAL_INCLUDE_DIRS src/util src/service src/module
   LINK_LIBRARIES ${_link_libraries}
+  PRIVATE_LINK_LIBRARIES nlohmann_json::nlohmann_json
   SOURCES ${_core_srcs}
   PUBLIC_HEADERS ${_core_public_headers}
   PRIVATE_HEADERS ${_core_private_headers}
   BINARY_RESOURCES manifest.json
 )
 
 set_property(
   TARGET CppMicroServices APPEND PROPERTY
   COMPILE_DEFINITIONS "MINIZ_NO_ARCHIVE_WRITING_API;MINIZ_NO_ZLIB_COMPATIBLE_NAMES"
   )
diff --git a/Modules/CppMicroServices/core/src/CMakeLists.txt b/Modules/CppMicroServices/core/src/CMakeLists.txt
index aeb9cf14bf..7d767f7b1b 100644
--- a/Modules/CppMicroServices/core/src/CMakeLists.txt
+++ b/Modules/CppMicroServices/core/src/CMakeLists.txt
@@ -1,84 +1,83 @@
 #-----------------------------------------------------------------------------
 # Source files
 #-----------------------------------------------------------------------------
 
 set(_srcs
   util/usAny.cpp
   util/usLDAPProp.cpp
   util/usSharedLibrary.cpp
   util/usUtils.cpp
 
   service/usLDAPExpr.cpp
   service/usLDAPFilter.cpp
   service/usServiceException.cpp
   service/usServiceEvent.cpp
   service/usServiceEventListenerHook.cpp
   service/usServiceFindHook.cpp
   service/usServiceHooks.cpp
   service/usServiceListenerEntry.cpp
   service/usServiceListenerEntry_p.h
   service/usServiceListenerHook.cpp
   service/usServiceListeners.cpp
   service/usServiceListeners_p.h
   service/usServiceObjects.cpp
   service/usServiceProperties.cpp
   service/usServicePropertiesImpl.cpp
   service/usServiceReferenceBase.cpp
   service/usServiceReferenceBasePrivate.cpp
   service/usServiceRegistrationBase.cpp
   service/usServiceRegistrationBasePrivate.cpp
   service/usServiceRegistry.cpp
   service/usServiceRegistry_p.h
 
   module/usCoreModuleActivator.cpp
   module/usCoreModuleContext_p.h
   module/usCoreModuleContext.cpp
   module/usModuleContext.cpp
   module/usModule.cpp
   module/usModuleEvent.cpp
   module/usModuleEventHook.cpp
   module/usModuleFindHook.cpp
   module/usModuleHooks.cpp
   module/usModuleInfo.cpp
   module/usModuleManifest.cpp
   module/usModulePrivate.cpp
   module/usModuleRegistry.cpp
   module/usModuleResource.cpp
   module/usModuleResourceBuffer.cpp
   module/usModuleResourceContainer.cpp
   module/usModuleResourceStream.cpp
   module/usModuleSettings.cpp
   module/usModuleUtils.cpp
   module/usModuleVersion.cpp
 
-  ../../third_party/jsoncpp.cpp
   ../../third_party/miniz.c
 )
 
 set(_private_headers
   util/usAtomicInt_p.h
   util/usListenerFunctors_p.h
   util/usLog_p.h
   util/usStaticInit_p.h
   util/usThreads_p.h
   util/usUtils_p.h
   util/usWaitCondition_p.h
 
   service/usServiceHooks_p.h
   service/usServiceListenerHook_p.h
   service/usServicePropertiesImpl_p.h
   service/usServiceTracker.tpp
   service/usServiceTrackerPrivate.h
   service/usServiceTrackerPrivate.tpp
   service/usTrackedService_p.h
   service/usTrackedServiceListener_p.h
   service/usTrackedService.tpp
 
   module/usModuleAbstractTracked_p.h
   module/usModuleAbstractTracked.tpp
   module/usModuleHooks_p.h
   module/usModuleResourceBuffer_p.h
   module/usModuleResourceContainer_p.h
   module/usModuleUtils_p.h
 )
 
diff --git a/Modules/CppMicroServices/core/src/module/usModuleManifest.cpp b/Modules/CppMicroServices/core/src/module/usModuleManifest.cpp
index 904d538cb7..c897cfc168 100644
--- a/Modules/CppMicroServices/core/src/module/usModuleManifest.cpp
+++ b/Modules/CppMicroServices/core/src/module/usModuleManifest.cpp
@@ -1,154 +1,156 @@
 /*============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center (DKFZ)
   All rights reserved.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 ============================================================================*/
 
 #include "usModuleManifest_p.h"
 
-#include "jsoncpp.h"
+#include <nlohmann/json.hpp>
 
 #include <stdexcept>
 
+using namespace nlohmann;
+
 US_BEGIN_NAMESPACE
 
 namespace {
 
   typedef std::map<std::string, Any> AnyMap;
   typedef std::vector<Any> AnyVector;
 
-  void ParseJsonObject(const Json::Value& jsonObject, AnyMap& anyMap);
-  void ParseJsonArray(const Json::Value& jsonArray, AnyVector& anyVector);
+  void ParseJsonObject(const json& jsonObject, AnyMap& anyMap);
+  void ParseJsonArray(const json& jsonArray, AnyVector& anyVector);
 
-  Any ParseJsonValue(const Json::Value& jsonValue)
+  Any ParseJsonValue(const json& jsonValue)
   {
-    if (jsonValue.isObject())
+    if (jsonValue.is_object())
     {
       Any any = AnyMap();
       ParseJsonObject(jsonValue, ref_any_cast<AnyMap>(any));
       return any;
     }
-    else if (jsonValue.isArray())
+    else if (jsonValue.is_array())
     {
       Any any = AnyVector();
       ParseJsonArray(jsonValue, ref_any_cast<AnyVector>(any));
       return any;
     }
-    else if (jsonValue.isString())
+    else if (jsonValue.is_string())
     {
-      return Any(jsonValue.asString());
+      return Any(jsonValue.get<std::string>());
     }
-    else if (jsonValue.isBool())
+    else if (jsonValue.is_boolean())
     {
-      return Any(jsonValue.asBool());
+      return Any(jsonValue.get<bool>());
     }
-    else if (jsonValue.isIntegral())
+    else if (jsonValue.is_number_integer())
     {
-      return Any(jsonValue.asInt());
+      return Any(jsonValue.get<int>());
     }
-    else if (jsonValue.isDouble())
+    else if (jsonValue.is_number_float())
     {
-      return Any(jsonValue.asDouble());
+      return Any(jsonValue.get<double>());
     }
 
     return Any();
   }
 
-  void ParseJsonObject(const Json::Value& jsonObject, AnyMap& anyMap)
+  void ParseJsonObject(const json& jsonObject, AnyMap& anyMap)
   {
-    for (Json::Value::const_iterator it = jsonObject.begin();
-         it != jsonObject.end(); ++it)
+    for (const auto& [key, jsonValue] : jsonObject.items())
     {
-      const Json::Value& jsonValue = *it;
       Any anyValue = ParseJsonValue(jsonValue);
       if (!anyValue.Empty())
       {
-        anyMap.insert(std::make_pair(it.name(), anyValue));
+        anyMap.insert(std::make_pair(key, anyValue));
       }
     }
   }
 
-  void ParseJsonArray(const Json::Value& jsonArray, AnyVector& anyVector)
+  void ParseJsonArray(const json& jsonArray, AnyVector& anyVector)
   {
-    for (Json::Value::const_iterator it = jsonArray.begin();
-         it != jsonArray.end(); ++it)
+    for (const auto& jsonValue : jsonArray)
     {
-      const Json::Value& jsonValue = *it;
       Any anyValue = ParseJsonValue(jsonValue);
       if (!anyValue.Empty())
       {
         anyVector.push_back(anyValue);
       }
     }
   }
 
 }
 
 ModuleManifest::ModuleManifest()
 {
 }
 
 void ModuleManifest::Parse(std::istream& is)
 {
-  Json::Value root;
-  Json::Reader jsonReader(Json::Features::strictMode());
-  if (!jsonReader.parse(is, root, false))
+  json root;
+
+  try
+  {
+    root = json::parse(is);
+  }
+  catch (const json::exception& e)
   {
-    throw std::runtime_error(jsonReader.getFormattedErrorMessages());
+    throw std::runtime_error(e.what());
   }
 
-  if (!root.isObject())
+  if (!root.is_object())
   {
     throw std::runtime_error("The Json root element must be an object.");
   }
 
   ParseJsonObject(root, m_Properties);
 }
 
 bool ModuleManifest::Contains(const std::string& key) const
 {
   return m_Properties.count(key) > 0;
 }
 
 Any ModuleManifest::GetValue(const std::string& key) const
 {
   AnyMap::const_iterator iter = m_Properties.find(key);
   if (iter != m_Properties.end())
   {
     return iter->second;
   }
   return Any();
 }
 
 std::vector<std::string> ModuleManifest::GetKeys() const
 {
   std::vector<std::string> keys;
   for (AnyMap::const_iterator iter = m_Properties.begin();
        iter != m_Properties.end(); ++iter)
   {
     keys.push_back(iter->first);
   }
   return keys;
 }
 
 void ModuleManifest::SetValue(const std::string& key, const Any& value)
 {
   m_Properties[key] = value;
 }
 
 US_END_NAMESPACE
diff --git a/Modules/CppMicroServices/third_party/jsoncpp.cpp b/Modules/CppMicroServices/third_party/jsoncpp.cpp
deleted file mode 100644
index 52ccdf35fa..0000000000
--- a/Modules/CppMicroServices/third_party/jsoncpp.cpp
+++ /dev/null
@@ -1,5337 +0,0 @@
-/// Json-cpp amalgamated source (http://jsoncpp.sourceforge.net/).
-/// It is intended to be used with #include "json/json.h"
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-/*
-The JsonCpp library's source code, including accompanying documentation,
-tests and demonstration applications, are licensed under the following
-conditions...
-
-Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all
-jurisdictions which recognize such a disclaimer. In such jurisdictions,
-this software is released into the Public Domain.
-
-In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
-2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
-The JsonCpp Authors, and is released under the terms of the MIT License (see below).
-
-In jurisdictions which recognize Public Domain property, the user of this
-software may choose to accept it either as 1) Public Domain, 2) under the
-conditions of the MIT License (see below), or 3) under the terms of dual
-Public Domain/MIT License conditions described here, as they choose.
-
-The MIT License is about as close to Public Domain as a license can get, and is
-described in clear, concise terms at:
-
-   http://en.wikipedia.org/wiki/MIT_License
-
-The full text of the MIT License follows:
-
-========================================================================
-Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use, copy,
-modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-========================================================================
-(END LICENSE TEXT)
-
-The MIT license is compatible with both the GPL and commercial
-software, affording one all of the rights of Public Domain with the
-minor nuisance of being required to keep the above copyright notice
-and license text in the source code. Note also that by accepting the
-Public Domain "license" you can re-license your copy using whatever
-license you like.
-
-*/
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-#include "jsoncpp.h"
-
-#ifndef JSON_IS_AMALGAMATION
-#error "Compile with -I PATH_TO_JSON_DIRECTORY"
-#endif
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: src/lib_json/json_tool.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED
-#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include <json/config.h>
-#endif
-
-// Also support old flag NO_LOCALE_SUPPORT
-#ifdef NO_LOCALE_SUPPORT
-#define JSONCPP_NO_LOCALE_SUPPORT
-#endif
-
-#ifndef JSONCPP_NO_LOCALE_SUPPORT
-#include <clocale>
-#endif
-
-/* This header provides common string manipulation support, such as UTF-8,
- * portable conversion from/to string...
- *
- * It is an internal header that must not be exposed.
- */
-
-namespace Json {
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunneeded-internal-declaration"
-#endif
-static inline char getDecimalPoint() {
-#ifdef JSONCPP_NO_LOCALE_SUPPORT
-  return '\0';
-#else
-  struct lconv* lc = localeconv();
-  return lc ? *(lc->decimal_point) : '\0';
-#endif
-}
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-/// Converts a unicode code-point to UTF-8.
-static inline String codePointToUTF8(unsigned int cp) {
-  String result;
-
-  // based on description from http://en.wikipedia.org/wiki/UTF-8
-
-  if (cp <= 0x7f) {
-    result.resize(1);
-    result[0] = static_cast<char>(cp);
-  } else if (cp <= 0x7FF) {
-    result.resize(2);
-    result[1] = static_cast<char>(0x80 | (0x3f & cp));
-    result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
-  } else if (cp <= 0xFFFF) {
-    result.resize(3);
-    result[2] = static_cast<char>(0x80 | (0x3f & cp));
-    result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
-    result[0] = static_cast<char>(0xE0 | (0xf & (cp >> 12)));
-  } else if (cp <= 0x10FFFF) {
-    result.resize(4);
-    result[3] = static_cast<char>(0x80 | (0x3f & cp));
-    result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
-    result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
-    result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
-  }
-
-  return result;
-}
-
-enum {
-  /// Constant that specify the size of the buffer that must be passed to
-  /// uintToString.
-  uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1
-};
-
-// Defines a char buffer for use with uintToString().
-using UIntToStringBuffer = char[uintToStringBufferSize];
-
-/** Converts an unsigned integer to string.
- * @param value Unsigned integer to convert to string
- * @param current Input/Output string buffer.
- *        Must have at least uintToStringBufferSize chars free.
- */
-static inline void uintToString(LargestUInt value, char*& current) {
-  *--current = 0;
-  do {
-    *--current = static_cast<char>(value % 10U + static_cast<unsigned>('0'));
-    value /= 10;
-  } while (value != 0);
-}
-
-/** Change ',' to '.' everywhere in buffer.
- *
- * We had a sophisticated way, but it did not work in WinCE.
- * @see https://github.com/open-source-parsers/jsoncpp/pull/9
- */
-template <typename Iter> Iter fixNumericLocale(Iter begin, Iter end) {
-  for (; begin != end; ++begin) {
-    if (*begin == ',') {
-      *begin = '.';
-    }
-  }
-  return begin;
-}
-
-template <typename Iter> void fixNumericLocaleInput(Iter begin, Iter end) {
-  char decimalPoint = getDecimalPoint();
-  if (decimalPoint == '\0' || decimalPoint == '.') {
-    return;
-  }
-  for (; begin != end; ++begin) {
-    if (*begin == '.') {
-      *begin = decimalPoint;
-    }
-  }
-}
-
-/**
- * Return iterator that would be the new end of the range [begin,end), if we
- * were to delete zeros in the end of string, but not the last zero before '.'.
- */
-template <typename Iter>
-Iter fixZerosInTheEnd(Iter begin, Iter end, unsigned int precision) {
-  for (; begin != end; --end) {
-    if (*(end - 1) != '0') {
-      return end;
-    }
-    // Don't delete the last zero before the decimal point.
-    if (begin != (end - 1) && begin != (end - 2) && *(end - 2) == '.') {
-      if (precision) {
-        return end;
-      }
-      return end - 2;
-    }
-  }
-  return end;
-}
-
-} // namespace Json
-
-#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: src/lib_json/json_tool.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: src/lib_json/json_reader.cpp
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2011 Baptiste Lepilleur and The JsonCpp Authors
-// Copyright (C) 2016 InfoTeCS JSC. All rights reserved.
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "json_tool.h"
-#include <json/assertions.h>
-#include <json/reader.h>
-#include <json/value.h>
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <algorithm>
-#include <cassert>
-#include <cstring>
-#include <iostream>
-#include <istream>
-#include <limits>
-#include <memory>
-#include <set>
-#include <sstream>
-#include <utility>
-
-#include <cstdio>
-#if __cplusplus >= 201103L
-
-#if !defined(sscanf)
-#define sscanf std::sscanf
-#endif
-
-#endif //__cplusplus
-
-#if defined(_MSC_VER)
-#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
-#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
-#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
-#endif //_MSC_VER
-
-#if defined(_MSC_VER)
-// Disable warning about strdup being deprecated.
-#pragma warning(disable : 4996)
-#endif
-
-// Define JSONCPP_DEPRECATED_STACK_LIMIT as an appropriate integer at compile
-// time to change the stack limit
-#if !defined(JSONCPP_DEPRECATED_STACK_LIMIT)
-#define JSONCPP_DEPRECATED_STACK_LIMIT 1000
-#endif
-
-static size_t const stackLimit_g =
-    JSONCPP_DEPRECATED_STACK_LIMIT; // see readValue()
-
-namespace Json {
-
-#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
-using CharReaderPtr = std::unique_ptr<CharReader>;
-#else
-using CharReaderPtr = std::auto_ptr<CharReader>;
-#endif
-
-// Implementation of class Features
-// ////////////////////////////////
-
-Features::Features() = default;
-
-Features Features::all() { return {}; }
-
-Features Features::strictMode() {
-  Features features;
-  features.allowComments_ = false;
-  features.strictRoot_ = true;
-  features.allowDroppedNullPlaceholders_ = false;
-  features.allowNumericKeys_ = false;
-  return features;
-}
-
-// Implementation of class Reader
-// ////////////////////////////////
-
-bool Reader::containsNewLine(Reader::Location begin, Reader::Location end) {
-  return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; });
-}
-
-// Class Reader
-// //////////////////////////////////////////////////////////////////
-
-Reader::Reader() : features_(Features::all()) {}
-
-Reader::Reader(const Features& features) : features_(features) {}
-
-bool Reader::parse(const std::string& document, Value& root,
-                   bool collectComments) {
-  document_.assign(document.begin(), document.end());
-  const char* begin = document_.c_str();
-  const char* end = begin + document_.length();
-  return parse(begin, end, root, collectComments);
-}
-
-bool Reader::parse(std::istream& is, Value& root, bool collectComments) {
-  // std::istream_iterator<char> begin(is);
-  // std::istream_iterator<char> end;
-  // Those would allow streamed input from a file, if parse() were a
-  // template function.
-
-  // Since String is reference-counted, this at least does not
-  // create an extra copy.
-  String doc(std::istreambuf_iterator<char>(is), {});
-  return parse(doc.data(), doc.data() + doc.size(), root, collectComments);
-}
-
-bool Reader::parse(const char* beginDoc, const char* endDoc, Value& root,
-                   bool collectComments) {
-  if (!features_.allowComments_) {
-    collectComments = false;
-  }
-
-  begin_ = beginDoc;
-  end_ = endDoc;
-  collectComments_ = collectComments;
-  current_ = begin_;
-  lastValueEnd_ = nullptr;
-  lastValue_ = nullptr;
-  commentsBefore_.clear();
-  errors_.clear();
-  while (!nodes_.empty())
-    nodes_.pop();
-  nodes_.push(&root);
-
-  bool successful = readValue();
-  Token token;
-  skipCommentTokens(token);
-  if (collectComments_ && !commentsBefore_.empty())
-    root.setComment(commentsBefore_, commentAfter);
-  if (features_.strictRoot_) {
-    if (!root.isArray() && !root.isObject()) {
-      // Set error location to start of doc, ideally should be first token found
-      // in doc
-      token.type_ = tokenError;
-      token.start_ = beginDoc;
-      token.end_ = endDoc;
-      addError(
-          "A valid JSON document must be either an array or an object value.",
-          token);
-      return false;
-    }
-  }
-  return successful;
-}
-
-bool Reader::readValue() {
-  // readValue() may call itself only if it calls readObject() or ReadArray().
-  // These methods execute nodes_.push() just before and nodes_.pop)() just
-  // after calling readValue(). parse() executes one nodes_.push(), so > instead
-  // of >=.
-  if (nodes_.size() > stackLimit_g)
-    throwRuntimeError("Exceeded stackLimit in readValue().");
-
-  Token token;
-  skipCommentTokens(token);
-  bool successful = true;
-
-  if (collectComments_ && !commentsBefore_.empty()) {
-    currentValue().setComment(commentsBefore_, commentBefore);
-    commentsBefore_.clear();
-  }
-
-  switch (token.type_) {
-  case tokenObjectBegin:
-    successful = readObject(token);
-    currentValue().setOffsetLimit(current_ - begin_);
-    break;
-  case tokenArrayBegin:
-    successful = readArray(token);
-    currentValue().setOffsetLimit(current_ - begin_);
-    break;
-  case tokenNumber:
-    successful = decodeNumber(token);
-    break;
-  case tokenString:
-    successful = decodeString(token);
-    break;
-  case tokenTrue: {
-    Value v(true);
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-  } break;
-  case tokenFalse: {
-    Value v(false);
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-  } break;
-  case tokenNull: {
-    Value v;
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-  } break;
-  case tokenArraySeparator:
-  case tokenObjectEnd:
-  case tokenArrayEnd:
-    if (features_.allowDroppedNullPlaceholders_) {
-      // "Un-read" the current token and mark the current value as a null
-      // token.
-      current_--;
-      Value v;
-      currentValue().swapPayload(v);
-      currentValue().setOffsetStart(current_ - begin_ - 1);
-      currentValue().setOffsetLimit(current_ - begin_);
-      break;
-    } // Else, fall through...
-  default:
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    return addError("Syntax error: value, object or array expected.", token);
-  }
-
-  if (collectComments_) {
-    lastValueEnd_ = current_;
-    lastValue_ = &currentValue();
-  }
-
-  return successful;
-}
-
-void Reader::skipCommentTokens(Token& token) {
-  if (features_.allowComments_) {
-    do {
-      readToken(token);
-    } while (token.type_ == tokenComment);
-  } else {
-    readToken(token);
-  }
-}
-
-bool Reader::readToken(Token& token) {
-  skipSpaces();
-  token.start_ = current_;
-  Char c = getNextChar();
-  bool ok = true;
-  switch (c) {
-  case '{':
-    token.type_ = tokenObjectBegin;
-    break;
-  case '}':
-    token.type_ = tokenObjectEnd;
-    break;
-  case '[':
-    token.type_ = tokenArrayBegin;
-    break;
-  case ']':
-    token.type_ = tokenArrayEnd;
-    break;
-  case '"':
-    token.type_ = tokenString;
-    ok = readString();
-    break;
-  case '/':
-    token.type_ = tokenComment;
-    ok = readComment();
-    break;
-  case '0':
-  case '1':
-  case '2':
-  case '3':
-  case '4':
-  case '5':
-  case '6':
-  case '7':
-  case '8':
-  case '9':
-  case '-':
-    token.type_ = tokenNumber;
-    readNumber();
-    break;
-  case 't':
-    token.type_ = tokenTrue;
-    ok = match("rue", 3);
-    break;
-  case 'f':
-    token.type_ = tokenFalse;
-    ok = match("alse", 4);
-    break;
-  case 'n':
-    token.type_ = tokenNull;
-    ok = match("ull", 3);
-    break;
-  case ',':
-    token.type_ = tokenArraySeparator;
-    break;
-  case ':':
-    token.type_ = tokenMemberSeparator;
-    break;
-  case 0:
-    token.type_ = tokenEndOfStream;
-    break;
-  default:
-    ok = false;
-    break;
-  }
-  if (!ok)
-    token.type_ = tokenError;
-  token.end_ = current_;
-  return ok;
-}
-
-void Reader::skipSpaces() {
-  while (current_ != end_) {
-    Char c = *current_;
-    if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
-      ++current_;
-    else
-      break;
-  }
-}
-
-bool Reader::match(const Char* pattern, int patternLength) {
-  if (end_ - current_ < patternLength)
-    return false;
-  int index = patternLength;
-  while (index--)
-    if (current_[index] != pattern[index])
-      return false;
-  current_ += patternLength;
-  return true;
-}
-
-bool Reader::readComment() {
-  Location commentBegin = current_ - 1;
-  Char c = getNextChar();
-  bool successful = false;
-  if (c == '*')
-    successful = readCStyleComment();
-  else if (c == '/')
-    successful = readCppStyleComment();
-  if (!successful)
-    return false;
-
-  if (collectComments_) {
-    CommentPlacement placement = commentBefore;
-    if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
-      if (c != '*' || !containsNewLine(commentBegin, current_))
-        placement = commentAfterOnSameLine;
-    }
-
-    addComment(commentBegin, current_, placement);
-  }
-  return true;
-}
-
-String Reader::normalizeEOL(Reader::Location begin, Reader::Location end) {
-  String normalized;
-  normalized.reserve(static_cast<size_t>(end - begin));
-  Reader::Location current = begin;
-  while (current != end) {
-    char c = *current++;
-    if (c == '\r') {
-      if (current != end && *current == '\n')
-        // convert dos EOL
-        ++current;
-      // convert Mac EOL
-      normalized += '\n';
-    } else {
-      normalized += c;
-    }
-  }
-  return normalized;
-}
-
-void Reader::addComment(Location begin, Location end,
-                        CommentPlacement placement) {
-  assert(collectComments_);
-  const String& normalized = normalizeEOL(begin, end);
-  if (placement == commentAfterOnSameLine) {
-    assert(lastValue_ != nullptr);
-    lastValue_->setComment(normalized, placement);
-  } else {
-    commentsBefore_ += normalized;
-  }
-}
-
-bool Reader::readCStyleComment() {
-  while ((current_ + 1) < end_) {
-    Char c = getNextChar();
-    if (c == '*' && *current_ == '/')
-      break;
-  }
-  return getNextChar() == '/';
-}
-
-bool Reader::readCppStyleComment() {
-  while (current_ != end_) {
-    Char c = getNextChar();
-    if (c == '\n')
-      break;
-    if (c == '\r') {
-      // Consume DOS EOL. It will be normalized in addComment.
-      if (current_ != end_ && *current_ == '\n')
-        getNextChar();
-      // Break on Moc OS 9 EOL.
-      break;
-    }
-  }
-  return true;
-}
-
-void Reader::readNumber() {
-  Location p = current_;
-  char c = '0'; // stopgap for already consumed character
-  // integral part
-  while (c >= '0' && c <= '9')
-    c = (current_ = p) < end_ ? *p++ : '\0';
-  // fractional part
-  if (c == '.') {
-    c = (current_ = p) < end_ ? *p++ : '\0';
-    while (c >= '0' && c <= '9')
-      c = (current_ = p) < end_ ? *p++ : '\0';
-  }
-  // exponential part
-  if (c == 'e' || c == 'E') {
-    c = (current_ = p) < end_ ? *p++ : '\0';
-    if (c == '+' || c == '-')
-      c = (current_ = p) < end_ ? *p++ : '\0';
-    while (c >= '0' && c <= '9')
-      c = (current_ = p) < end_ ? *p++ : '\0';
-  }
-}
-
-bool Reader::readString() {
-  Char c = '\0';
-  while (current_ != end_) {
-    c = getNextChar();
-    if (c == '\\')
-      getNextChar();
-    else if (c == '"')
-      break;
-  }
-  return c == '"';
-}
-
-bool Reader::readObject(Token& token) {
-  Token tokenName;
-  String name;
-  Value init(objectValue);
-  currentValue().swapPayload(init);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  while (readToken(tokenName)) {
-    bool initialTokenOk = true;
-    while (tokenName.type_ == tokenComment && initialTokenOk)
-      initialTokenOk = readToken(tokenName);
-    if (!initialTokenOk)
-      break;
-    if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
-      return true;
-    name.clear();
-    if (tokenName.type_ == tokenString) {
-      if (!decodeString(tokenName, name))
-        return recoverFromError(tokenObjectEnd);
-    } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
-      Value numberName;
-      if (!decodeNumber(tokenName, numberName))
-        return recoverFromError(tokenObjectEnd);
-      name = numberName.asString();
-    } else {
-      break;
-    }
-
-    Token colon;
-    if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
-      return addErrorAndRecover("Missing ':' after object member name", colon,
-                                tokenObjectEnd);
-    }
-    Value& value = currentValue()[name];
-    nodes_.push(&value);
-    bool ok = readValue();
-    nodes_.pop();
-    if (!ok) // error already set
-      return recoverFromError(tokenObjectEnd);
-
-    Token comma;
-    if (!readToken(comma) ||
-        (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
-         comma.type_ != tokenComment)) {
-      return addErrorAndRecover("Missing ',' or '}' in object declaration",
-                                comma, tokenObjectEnd);
-    }
-    bool finalizeTokenOk = true;
-    while (comma.type_ == tokenComment && finalizeTokenOk)
-      finalizeTokenOk = readToken(comma);
-    if (comma.type_ == tokenObjectEnd)
-      return true;
-  }
-  return addErrorAndRecover("Missing '}' or object member name", tokenName,
-                            tokenObjectEnd);
-}
-
-bool Reader::readArray(Token& token) {
-  Value init(arrayValue);
-  currentValue().swapPayload(init);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  skipSpaces();
-  if (current_ != end_ && *current_ == ']') // empty array
-  {
-    Token endArray;
-    readToken(endArray);
-    return true;
-  }
-  int index = 0;
-  for (;;) {
-    Value& value = currentValue()[index++];
-    nodes_.push(&value);
-    bool ok = readValue();
-    nodes_.pop();
-    if (!ok) // error already set
-      return recoverFromError(tokenArrayEnd);
-
-    Token currentToken;
-    // Accept Comment after last item in the array.
-    ok = readToken(currentToken);
-    while (currentToken.type_ == tokenComment && ok) {
-      ok = readToken(currentToken);
-    }
-    bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
-                         currentToken.type_ != tokenArrayEnd);
-    if (!ok || badTokenType) {
-      return addErrorAndRecover("Missing ',' or ']' in array declaration",
-                                currentToken, tokenArrayEnd);
-    }
-    if (currentToken.type_ == tokenArrayEnd)
-      break;
-  }
-  return true;
-}
-
-bool Reader::decodeNumber(Token& token) {
-  Value decoded;
-  if (!decodeNumber(token, decoded))
-    return false;
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
-  return true;
-}
-
-bool Reader::decodeNumber(Token& token, Value& decoded) {
-  // Attempts to parse the number as an integer. If the number is
-  // larger than the maximum supported value of an integer then
-  // we decode the number as a double.
-  Location current = token.start_;
-  bool isNegative = *current == '-';
-  if (isNegative)
-    ++current;
-  // TODO: Help the compiler do the div and mod at compile time or get rid of
-  // them.
-  Value::LargestUInt maxIntegerValue =
-      isNegative ? Value::LargestUInt(Value::maxLargestInt) + 1
-                 : Value::maxLargestUInt;
-  Value::LargestUInt threshold = maxIntegerValue / 10;
-  Value::LargestUInt value = 0;
-  while (current < token.end_) {
-    Char c = *current++;
-    if (c < '0' || c > '9')
-      return decodeDouble(token, decoded);
-    auto digit(static_cast<Value::UInt>(c - '0'));
-    if (value >= threshold) {
-      // We've hit or exceeded the max value divided by 10 (rounded down). If
-      // a) we've only just touched the limit, b) this is the last digit, and
-      // c) it's small enough to fit in that rounding delta, we're okay.
-      // Otherwise treat this number as a double to avoid overflow.
-      if (value > threshold || current != token.end_ ||
-          digit > maxIntegerValue % 10) {
-        return decodeDouble(token, decoded);
-      }
-    }
-    value = value * 10 + digit;
-  }
-  if (isNegative && value == maxIntegerValue)
-    decoded = Value::minLargestInt;
-  else if (isNegative)
-    decoded = -Value::LargestInt(value);
-  else if (value <= Value::LargestUInt(Value::maxInt))
-    decoded = Value::LargestInt(value);
-  else
-    decoded = value;
-  return true;
-}
-
-bool Reader::decodeDouble(Token& token) {
-  Value decoded;
-  if (!decodeDouble(token, decoded))
-    return false;
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
-  return true;
-}
-
-bool Reader::decodeDouble(Token& token, Value& decoded) {
-  double value = 0;
-  String buffer(token.start_, token.end_);
-  IStringStream is(buffer);
-  if (!(is >> value))
-    return addError(
-        "'" + String(token.start_, token.end_) + "' is not a number.", token);
-  decoded = value;
-  return true;
-}
-
-bool Reader::decodeString(Token& token) {
-  String decoded_string;
-  if (!decodeString(token, decoded_string))
-    return false;
-  Value decoded(decoded_string);
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
-  return true;
-}
-
-bool Reader::decodeString(Token& token, String& decoded) {
-  decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
-  Location current = token.start_ + 1; // skip '"'
-  Location end = token.end_ - 1;       // do not include '"'
-  while (current != end) {
-    Char c = *current++;
-    if (c == '"')
-      break;
-    if (c == '\\') {
-      if (current == end)
-        return addError("Empty escape sequence in string", token, current);
-      Char escape = *current++;
-      switch (escape) {
-      case '"':
-        decoded += '"';
-        break;
-      case '/':
-        decoded += '/';
-        break;
-      case '\\':
-        decoded += '\\';
-        break;
-      case 'b':
-        decoded += '\b';
-        break;
-      case 'f':
-        decoded += '\f';
-        break;
-      case 'n':
-        decoded += '\n';
-        break;
-      case 'r':
-        decoded += '\r';
-        break;
-      case 't':
-        decoded += '\t';
-        break;
-      case 'u': {
-        unsigned int unicode;
-        if (!decodeUnicodeCodePoint(token, current, end, unicode))
-          return false;
-        decoded += codePointToUTF8(unicode);
-      } break;
-      default:
-        return addError("Bad escape sequence in string", token, current);
-      }
-    } else {
-      decoded += c;
-    }
-  }
-  return true;
-}
-
-bool Reader::decodeUnicodeCodePoint(Token& token, Location& current,
-                                    Location end, unsigned int& unicode) {
-
-  if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
-    return false;
-  if (unicode >= 0xD800 && unicode <= 0xDBFF) {
-    // surrogate pairs
-    if (end - current < 6)
-      return addError(
-          "additional six characters expected to parse unicode surrogate pair.",
-          token, current);
-    if (*(current++) == '\\' && *(current++) == 'u') {
-      unsigned int surrogatePair;
-      if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
-        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
-      } else
-        return false;
-    } else
-      return addError("expecting another \\u token to begin the second half of "
-                      "a unicode surrogate pair",
-                      token, current);
-  }
-  return true;
-}
-
-bool Reader::decodeUnicodeEscapeSequence(Token& token, Location& current,
-                                         Location end,
-                                         unsigned int& ret_unicode) {
-  if (end - current < 4)
-    return addError(
-        "Bad unicode escape sequence in string: four digits expected.", token,
-        current);
-  int unicode = 0;
-  for (int index = 0; index < 4; ++index) {
-    Char c = *current++;
-    unicode *= 16;
-    if (c >= '0' && c <= '9')
-      unicode += c - '0';
-    else if (c >= 'a' && c <= 'f')
-      unicode += c - 'a' + 10;
-    else if (c >= 'A' && c <= 'F')
-      unicode += c - 'A' + 10;
-    else
-      return addError(
-          "Bad unicode escape sequence in string: hexadecimal digit expected.",
-          token, current);
-  }
-  ret_unicode = static_cast<unsigned int>(unicode);
-  return true;
-}
-
-bool Reader::addError(const String& message, Token& token, Location extra) {
-  ErrorInfo info;
-  info.token_ = token;
-  info.message_ = message;
-  info.extra_ = extra;
-  errors_.push_back(info);
-  return false;
-}
-
-bool Reader::recoverFromError(TokenType skipUntilToken) {
-  size_t const errorCount = errors_.size();
-  Token skip;
-  for (;;) {
-    if (!readToken(skip))
-      errors_.resize(errorCount); // discard errors caused by recovery
-    if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
-      break;
-  }
-  errors_.resize(errorCount);
-  return false;
-}
-
-bool Reader::addErrorAndRecover(const String& message, Token& token,
-                                TokenType skipUntilToken) {
-  addError(message, token);
-  return recoverFromError(skipUntilToken);
-}
-
-Value& Reader::currentValue() { return *(nodes_.top()); }
-
-Reader::Char Reader::getNextChar() {
-  if (current_ == end_)
-    return 0;
-  return *current_++;
-}
-
-void Reader::getLocationLineAndColumn(Location location, int& line,
-                                      int& column) const {
-  Location current = begin_;
-  Location lastLineStart = current;
-  line = 0;
-  while (current < location && current != end_) {
-    Char c = *current++;
-    if (c == '\r') {
-      if (*current == '\n')
-        ++current;
-      lastLineStart = current;
-      ++line;
-    } else if (c == '\n') {
-      lastLineStart = current;
-      ++line;
-    }
-  }
-  // column & line start at 1
-  column = int(location - lastLineStart) + 1;
-  ++line;
-}
-
-String Reader::getLocationLineAndColumn(Location location) const {
-  int line, column;
-  getLocationLineAndColumn(location, line, column);
-  char buffer[18 + 16 + 16 + 1];
-  jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
-  return buffer;
-}
-
-// Deprecated. Preserved for backward compatibility
-String Reader::getFormatedErrorMessages() const {
-  return getFormattedErrorMessages();
-}
-
-String Reader::getFormattedErrorMessages() const {
-  String formattedMessage;
-  for (const auto& error : errors_) {
-    formattedMessage +=
-        "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
-    formattedMessage += "  " + error.message_ + "\n";
-    if (error.extra_)
-      formattedMessage +=
-          "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
-  }
-  return formattedMessage;
-}
-
-std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
-  std::vector<Reader::StructuredError> allErrors;
-  for (const auto& error : errors_) {
-    Reader::StructuredError structured;
-    structured.offset_start = error.token_.start_ - begin_;
-    structured.offset_limit = error.token_.end_ - begin_;
-    structured.message = error.message_;
-    allErrors.push_back(structured);
-  }
-  return allErrors;
-}
-
-bool Reader::pushError(const Value& value, const String& message) {
-  ptrdiff_t const length = end_ - begin_;
-  if (value.getOffsetStart() > length || value.getOffsetLimit() > length)
-    return false;
-  Token token;
-  token.type_ = tokenError;
-  token.start_ = begin_ + value.getOffsetStart();
-  token.end_ = begin_ + value.getOffsetLimit();
-  ErrorInfo info;
-  info.token_ = token;
-  info.message_ = message;
-  info.extra_ = nullptr;
-  errors_.push_back(info);
-  return true;
-}
-
-bool Reader::pushError(const Value& value, const String& message,
-                       const Value& extra) {
-  ptrdiff_t const length = end_ - begin_;
-  if (value.getOffsetStart() > length || value.getOffsetLimit() > length ||
-      extra.getOffsetLimit() > length)
-    return false;
-  Token token;
-  token.type_ = tokenError;
-  token.start_ = begin_ + value.getOffsetStart();
-  token.end_ = begin_ + value.getOffsetLimit();
-  ErrorInfo info;
-  info.token_ = token;
-  info.message_ = message;
-  info.extra_ = begin_ + extra.getOffsetStart();
-  errors_.push_back(info);
-  return true;
-}
-
-bool Reader::good() const { return errors_.empty(); }
-
-// Originally copied from the Features class (now deprecated), used internally
-// for features implementation.
-class OurFeatures {
-public:
-  static OurFeatures all();
-  bool allowComments_;
-  bool allowTrailingCommas_;
-  bool strictRoot_;
-  bool allowDroppedNullPlaceholders_;
-  bool allowNumericKeys_;
-  bool allowSingleQuotes_;
-  bool failIfExtra_;
-  bool rejectDupKeys_;
-  bool allowSpecialFloats_;
-  bool skipBom_;
-  size_t stackLimit_;
-}; // OurFeatures
-
-OurFeatures OurFeatures::all() { return {}; }
-
-// Implementation of class Reader
-// ////////////////////////////////
-
-// Originally copied from the Reader class (now deprecated), used internally
-// for implementing JSON reading.
-class OurReader {
-public:
-  using Char = char;
-  using Location = const Char*;
-  struct StructuredError {
-    ptrdiff_t offset_start;
-    ptrdiff_t offset_limit;
-    String message;
-  };
-
-  explicit OurReader(OurFeatures const& features);
-  bool parse(const char* beginDoc, const char* endDoc, Value& root,
-             bool collectComments = true);
-  String getFormattedErrorMessages() const;
-  std::vector<StructuredError> getStructuredErrors() const;
-
-private:
-  OurReader(OurReader const&);      // no impl
-  void operator=(OurReader const&); // no impl
-
-  enum TokenType {
-    tokenEndOfStream = 0,
-    tokenObjectBegin,
-    tokenObjectEnd,
-    tokenArrayBegin,
-    tokenArrayEnd,
-    tokenString,
-    tokenNumber,
-    tokenTrue,
-    tokenFalse,
-    tokenNull,
-    tokenNaN,
-    tokenPosInf,
-    tokenNegInf,
-    tokenArraySeparator,
-    tokenMemberSeparator,
-    tokenComment,
-    tokenError
-  };
-
-  class Token {
-  public:
-    TokenType type_;
-    Location start_;
-    Location end_;
-  };
-
-  class ErrorInfo {
-  public:
-    Token token_;
-    String message_;
-    Location extra_;
-  };
-
-  using Errors = std::deque<ErrorInfo>;
-
-  bool readToken(Token& token);
-  void skipSpaces();
-  void skipBom(bool skipBom);
-  bool match(const Char* pattern, int patternLength);
-  bool readComment();
-  bool readCStyleComment(bool* containsNewLineResult);
-  bool readCppStyleComment();
-  bool readString();
-  bool readStringSingleQuote();
-  bool readNumber(bool checkInf);
-  bool readValue();
-  bool readObject(Token& token);
-  bool readArray(Token& token);
-  bool decodeNumber(Token& token);
-  bool decodeNumber(Token& token, Value& decoded);
-  bool decodeString(Token& token);
-  bool decodeString(Token& token, String& decoded);
-  bool decodeDouble(Token& token);
-  bool decodeDouble(Token& token, Value& decoded);
-  bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
-                              unsigned int& unicode);
-  bool decodeUnicodeEscapeSequence(Token& token, Location& current,
-                                   Location end, unsigned int& unicode);
-  bool addError(const String& message, Token& token, Location extra = nullptr);
-  bool recoverFromError(TokenType skipUntilToken);
-  bool addErrorAndRecover(const String& message, Token& token,
-                          TokenType skipUntilToken);
-  void skipUntilSpace();
-  Value& currentValue();
-  Char getNextChar();
-  void getLocationLineAndColumn(Location location, int& line,
-                                int& column) const;
-  String getLocationLineAndColumn(Location location) const;
-  void addComment(Location begin, Location end, CommentPlacement placement);
-  void skipCommentTokens(Token& token);
-
-  static String normalizeEOL(Location begin, Location end);
-  static bool containsNewLine(Location begin, Location end);
-
-  using Nodes = std::stack<Value*>;
-
-  Nodes nodes_{};
-  Errors errors_{};
-  String document_{};
-  Location begin_ = nullptr;
-  Location end_ = nullptr;
-  Location current_ = nullptr;
-  Location lastValueEnd_ = nullptr;
-  Value* lastValue_ = nullptr;
-  bool lastValueHasAComment_ = false;
-  String commentsBefore_{};
-
-  OurFeatures const features_;
-  bool collectComments_ = false;
-}; // OurReader
-
-// complete copy of Read impl, for OurReader
-
-bool OurReader::containsNewLine(OurReader::Location begin,
-                                OurReader::Location end) {
-  return std::any_of(begin, end, [](char b) { return b == '\n' || b == '\r'; });
-}
-
-OurReader::OurReader(OurFeatures const& features) : features_(features) {}
-
-bool OurReader::parse(const char* beginDoc, const char* endDoc, Value& root,
-                      bool collectComments) {
-  if (!features_.allowComments_) {
-    collectComments = false;
-  }
-
-  begin_ = beginDoc;
-  end_ = endDoc;
-  collectComments_ = collectComments;
-  current_ = begin_;
-  lastValueEnd_ = nullptr;
-  lastValue_ = nullptr;
-  commentsBefore_.clear();
-  errors_.clear();
-  while (!nodes_.empty())
-    nodes_.pop();
-  nodes_.push(&root);
-
-  // skip byte order mark if it exists at the beginning of the UTF-8 text.
-  skipBom(features_.skipBom_);
-  bool successful = readValue();
-  nodes_.pop();
-  Token token;
-  skipCommentTokens(token);
-  if (features_.failIfExtra_ && (token.type_ != tokenEndOfStream)) {
-    addError("Extra non-whitespace after JSON value.", token);
-    return false;
-  }
-  if (collectComments_ && !commentsBefore_.empty())
-    root.setComment(commentsBefore_, commentAfter);
-  if (features_.strictRoot_) {
-    if (!root.isArray() && !root.isObject()) {
-      // Set error location to start of doc, ideally should be first token found
-      // in doc
-      token.type_ = tokenError;
-      token.start_ = beginDoc;
-      token.end_ = endDoc;
-      addError(
-          "A valid JSON document must be either an array or an object value.",
-          token);
-      return false;
-    }
-  }
-  return successful;
-}
-
-bool OurReader::readValue() {
-  //  To preserve the old behaviour we cast size_t to int.
-  if (nodes_.size() > features_.stackLimit_)
-    throwRuntimeError("Exceeded stackLimit in readValue().");
-  Token token;
-  skipCommentTokens(token);
-  bool successful = true;
-
-  if (collectComments_ && !commentsBefore_.empty()) {
-    currentValue().setComment(commentsBefore_, commentBefore);
-    commentsBefore_.clear();
-  }
-
-  switch (token.type_) {
-  case tokenObjectBegin:
-    successful = readObject(token);
-    currentValue().setOffsetLimit(current_ - begin_);
-    break;
-  case tokenArrayBegin:
-    successful = readArray(token);
-    currentValue().setOffsetLimit(current_ - begin_);
-    break;
-  case tokenNumber:
-    successful = decodeNumber(token);
-    break;
-  case tokenString:
-    successful = decodeString(token);
-    break;
-  case tokenTrue: {
-    Value v(true);
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-  } break;
-  case tokenFalse: {
-    Value v(false);
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-  } break;
-  case tokenNull: {
-    Value v;
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-  } break;
-  case tokenNaN: {
-    Value v(std::numeric_limits<double>::quiet_NaN());
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-  } break;
-  case tokenPosInf: {
-    Value v(std::numeric_limits<double>::infinity());
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-  } break;
-  case tokenNegInf: {
-    Value v(-std::numeric_limits<double>::infinity());
-    currentValue().swapPayload(v);
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-  } break;
-  case tokenArraySeparator:
-  case tokenObjectEnd:
-  case tokenArrayEnd:
-    if (features_.allowDroppedNullPlaceholders_) {
-      // "Un-read" the current token and mark the current value as a null
-      // token.
-      current_--;
-      Value v;
-      currentValue().swapPayload(v);
-      currentValue().setOffsetStart(current_ - begin_ - 1);
-      currentValue().setOffsetLimit(current_ - begin_);
-      break;
-    } // else, fall through ...
-  default:
-    currentValue().setOffsetStart(token.start_ - begin_);
-    currentValue().setOffsetLimit(token.end_ - begin_);
-    return addError("Syntax error: value, object or array expected.", token);
-  }
-
-  if (collectComments_) {
-    lastValueEnd_ = current_;
-    lastValueHasAComment_ = false;
-    lastValue_ = &currentValue();
-  }
-
-  return successful;
-}
-
-void OurReader::skipCommentTokens(Token& token) {
-  if (features_.allowComments_) {
-    do {
-      readToken(token);
-    } while (token.type_ == tokenComment);
-  } else {
-    readToken(token);
-  }
-}
-
-bool OurReader::readToken(Token& token) {
-  skipSpaces();
-  token.start_ = current_;
-  Char c = getNextChar();
-  bool ok = true;
-  switch (c) {
-  case '{':
-    token.type_ = tokenObjectBegin;
-    break;
-  case '}':
-    token.type_ = tokenObjectEnd;
-    break;
-  case '[':
-    token.type_ = tokenArrayBegin;
-    break;
-  case ']':
-    token.type_ = tokenArrayEnd;
-    break;
-  case '"':
-    token.type_ = tokenString;
-    ok = readString();
-    break;
-  case '\'':
-    if (features_.allowSingleQuotes_) {
-      token.type_ = tokenString;
-      ok = readStringSingleQuote();
-    } else {
-      // If we don't allow single quotes, this is a failure case.
-      ok = false;
-    }
-    break;
-  case '/':
-    token.type_ = tokenComment;
-    ok = readComment();
-    break;
-  case '0':
-  case '1':
-  case '2':
-  case '3':
-  case '4':
-  case '5':
-  case '6':
-  case '7':
-  case '8':
-  case '9':
-    token.type_ = tokenNumber;
-    readNumber(false);
-    break;
-  case '-':
-    if (readNumber(true)) {
-      token.type_ = tokenNumber;
-    } else {
-      token.type_ = tokenNegInf;
-      ok = features_.allowSpecialFloats_ && match("nfinity", 7);
-    }
-    break;
-  case '+':
-    if (readNumber(true)) {
-      token.type_ = tokenNumber;
-    } else {
-      token.type_ = tokenPosInf;
-      ok = features_.allowSpecialFloats_ && match("nfinity", 7);
-    }
-    break;
-  case 't':
-    token.type_ = tokenTrue;
-    ok = match("rue", 3);
-    break;
-  case 'f':
-    token.type_ = tokenFalse;
-    ok = match("alse", 4);
-    break;
-  case 'n':
-    token.type_ = tokenNull;
-    ok = match("ull", 3);
-    break;
-  case 'N':
-    if (features_.allowSpecialFloats_) {
-      token.type_ = tokenNaN;
-      ok = match("aN", 2);
-    } else {
-      ok = false;
-    }
-    break;
-  case 'I':
-    if (features_.allowSpecialFloats_) {
-      token.type_ = tokenPosInf;
-      ok = match("nfinity", 7);
-    } else {
-      ok = false;
-    }
-    break;
-  case ',':
-    token.type_ = tokenArraySeparator;
-    break;
-  case ':':
-    token.type_ = tokenMemberSeparator;
-    break;
-  case 0:
-    token.type_ = tokenEndOfStream;
-    break;
-  default:
-    ok = false;
-    break;
-  }
-  if (!ok)
-    token.type_ = tokenError;
-  token.end_ = current_;
-  return ok;
-}
-
-void OurReader::skipSpaces() {
-  while (current_ != end_) {
-    Char c = *current_;
-    if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
-      ++current_;
-    else
-      break;
-  }
-}
-
-void OurReader::skipBom(bool skipBom) {
-  // The default behavior is to skip BOM.
-  if (skipBom) {
-    if ((end_ - begin_) >= 3 && strncmp(begin_, "\xEF\xBB\xBF", 3) == 0) {
-      begin_ += 3;
-      current_ = begin_;
-    }
-  }
-}
-
-bool OurReader::match(const Char* pattern, int patternLength) {
-  if (end_ - current_ < patternLength)
-    return false;
-  int index = patternLength;
-  while (index--)
-    if (current_[index] != pattern[index])
-      return false;
-  current_ += patternLength;
-  return true;
-}
-
-bool OurReader::readComment() {
-  const Location commentBegin = current_ - 1;
-  const Char c = getNextChar();
-  bool successful = false;
-  bool cStyleWithEmbeddedNewline = false;
-
-  const bool isCStyleComment = (c == '*');
-  const bool isCppStyleComment = (c == '/');
-  if (isCStyleComment) {
-    successful = readCStyleComment(&cStyleWithEmbeddedNewline);
-  } else if (isCppStyleComment) {
-    successful = readCppStyleComment();
-  }
-
-  if (!successful)
-    return false;
-
-  if (collectComments_) {
-    CommentPlacement placement = commentBefore;
-
-    if (!lastValueHasAComment_) {
-      if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
-        if (isCppStyleComment || !cStyleWithEmbeddedNewline) {
-          placement = commentAfterOnSameLine;
-          lastValueHasAComment_ = true;
-        }
-      }
-    }
-
-    addComment(commentBegin, current_, placement);
-  }
-  return true;
-}
-
-String OurReader::normalizeEOL(OurReader::Location begin,
-                               OurReader::Location end) {
-  String normalized;
-  normalized.reserve(static_cast<size_t>(end - begin));
-  OurReader::Location current = begin;
-  while (current != end) {
-    char c = *current++;
-    if (c == '\r') {
-      if (current != end && *current == '\n')
-        // convert dos EOL
-        ++current;
-      // convert Mac EOL
-      normalized += '\n';
-    } else {
-      normalized += c;
-    }
-  }
-  return normalized;
-}
-
-void OurReader::addComment(Location begin, Location end,
-                           CommentPlacement placement) {
-  assert(collectComments_);
-  const String& normalized = normalizeEOL(begin, end);
-  if (placement == commentAfterOnSameLine) {
-    assert(lastValue_ != nullptr);
-    lastValue_->setComment(normalized, placement);
-  } else {
-    commentsBefore_ += normalized;
-  }
-}
-
-bool OurReader::readCStyleComment(bool* containsNewLineResult) {
-  *containsNewLineResult = false;
-
-  while ((current_ + 1) < end_) {
-    Char c = getNextChar();
-    if (c == '*' && *current_ == '/')
-      break;
-    if (c == '\n')
-      *containsNewLineResult = true;
-  }
-
-  return getNextChar() == '/';
-}
-
-bool OurReader::readCppStyleComment() {
-  while (current_ != end_) {
-    Char c = getNextChar();
-    if (c == '\n')
-      break;
-    if (c == '\r') {
-      // Consume DOS EOL. It will be normalized in addComment.
-      if (current_ != end_ && *current_ == '\n')
-        getNextChar();
-      // Break on Moc OS 9 EOL.
-      break;
-    }
-  }
-  return true;
-}
-
-bool OurReader::readNumber(bool checkInf) {
-  Location p = current_;
-  if (checkInf && p != end_ && *p == 'I') {
-    current_ = ++p;
-    return false;
-  }
-  char c = '0'; // stopgap for already consumed character
-  // integral part
-  while (c >= '0' && c <= '9')
-    c = (current_ = p) < end_ ? *p++ : '\0';
-  // fractional part
-  if (c == '.') {
-    c = (current_ = p) < end_ ? *p++ : '\0';
-    while (c >= '0' && c <= '9')
-      c = (current_ = p) < end_ ? *p++ : '\0';
-  }
-  // exponential part
-  if (c == 'e' || c == 'E') {
-    c = (current_ = p) < end_ ? *p++ : '\0';
-    if (c == '+' || c == '-')
-      c = (current_ = p) < end_ ? *p++ : '\0';
-    while (c >= '0' && c <= '9')
-      c = (current_ = p) < end_ ? *p++ : '\0';
-  }
-  return true;
-}
-bool OurReader::readString() {
-  Char c = 0;
-  while (current_ != end_) {
-    c = getNextChar();
-    if (c == '\\')
-      getNextChar();
-    else if (c == '"')
-      break;
-  }
-  return c == '"';
-}
-
-bool OurReader::readStringSingleQuote() {
-  Char c = 0;
-  while (current_ != end_) {
-    c = getNextChar();
-    if (c == '\\')
-      getNextChar();
-    else if (c == '\'')
-      break;
-  }
-  return c == '\'';
-}
-
-bool OurReader::readObject(Token& token) {
-  Token tokenName;
-  String name;
-  Value init(objectValue);
-  currentValue().swapPayload(init);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  while (readToken(tokenName)) {
-    bool initialTokenOk = true;
-    while (tokenName.type_ == tokenComment && initialTokenOk)
-      initialTokenOk = readToken(tokenName);
-    if (!initialTokenOk)
-      break;
-    if (tokenName.type_ == tokenObjectEnd &&
-        (name.empty() ||
-         features_.allowTrailingCommas_)) // empty object or trailing comma
-      return true;
-    name.clear();
-    if (tokenName.type_ == tokenString) {
-      if (!decodeString(tokenName, name))
-        return recoverFromError(tokenObjectEnd);
-    } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
-      Value numberName;
-      if (!decodeNumber(tokenName, numberName))
-        return recoverFromError(tokenObjectEnd);
-      name = numberName.asString();
-    } else {
-      break;
-    }
-    if (name.length() >= (1U << 30))
-      throwRuntimeError("keylength >= 2^30");
-    if (features_.rejectDupKeys_ && currentValue().isMember(name)) {
-      String msg = "Duplicate key: '" + name + "'";
-      return addErrorAndRecover(msg, tokenName, tokenObjectEnd);
-    }
-
-    Token colon;
-    if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
-      return addErrorAndRecover("Missing ':' after object member name", colon,
-                                tokenObjectEnd);
-    }
-    Value& value = currentValue()[name];
-    nodes_.push(&value);
-    bool ok = readValue();
-    nodes_.pop();
-    if (!ok) // error already set
-      return recoverFromError(tokenObjectEnd);
-
-    Token comma;
-    if (!readToken(comma) ||
-        (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
-         comma.type_ != tokenComment)) {
-      return addErrorAndRecover("Missing ',' or '}' in object declaration",
-                                comma, tokenObjectEnd);
-    }
-    bool finalizeTokenOk = true;
-    while (comma.type_ == tokenComment && finalizeTokenOk)
-      finalizeTokenOk = readToken(comma);
-    if (comma.type_ == tokenObjectEnd)
-      return true;
-  }
-  return addErrorAndRecover("Missing '}' or object member name", tokenName,
-                            tokenObjectEnd);
-}
-
-bool OurReader::readArray(Token& token) {
-  Value init(arrayValue);
-  currentValue().swapPayload(init);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  int index = 0;
-  for (;;) {
-    skipSpaces();
-    if (current_ != end_ && *current_ == ']' &&
-        (index == 0 ||
-         (features_.allowTrailingCommas_ &&
-          !features_.allowDroppedNullPlaceholders_))) // empty array or trailing
-                                                      // comma
-    {
-      Token endArray;
-      readToken(endArray);
-      return true;
-    }
-    Value& value = currentValue()[index++];
-    nodes_.push(&value);
-    bool ok = readValue();
-    nodes_.pop();
-    if (!ok) // error already set
-      return recoverFromError(tokenArrayEnd);
-
-    Token currentToken;
-    // Accept Comment after last item in the array.
-    ok = readToken(currentToken);
-    while (currentToken.type_ == tokenComment && ok) {
-      ok = readToken(currentToken);
-    }
-    bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
-                         currentToken.type_ != tokenArrayEnd);
-    if (!ok || badTokenType) {
-      return addErrorAndRecover("Missing ',' or ']' in array declaration",
-                                currentToken, tokenArrayEnd);
-    }
-    if (currentToken.type_ == tokenArrayEnd)
-      break;
-  }
-  return true;
-}
-
-bool OurReader::decodeNumber(Token& token) {
-  Value decoded;
-  if (!decodeNumber(token, decoded))
-    return false;
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
-  return true;
-}
-
-bool OurReader::decodeNumber(Token& token, Value& decoded) {
-  // Attempts to parse the number as an integer. If the number is
-  // larger than the maximum supported value of an integer then
-  // we decode the number as a double.
-  Location current = token.start_;
-  const bool isNegative = *current == '-';
-  if (isNegative) {
-    ++current;
-  }
-
-  // We assume we can represent the largest and smallest integer types as
-  // unsigned integers with separate sign. This is only true if they can fit
-  // into an unsigned integer.
-  static_assert(Value::maxLargestInt <= Value::maxLargestUInt,
-                "Int must be smaller than UInt");
-
-  // We need to convert minLargestInt into a positive number. The easiest way
-  // to do this conversion is to assume our "threshold" value of minLargestInt
-  // divided by 10 can fit in maxLargestInt when absolute valued. This should
-  // be a safe assumption.
-  static_assert(Value::minLargestInt <= -Value::maxLargestInt,
-                "The absolute value of minLargestInt must be greater than or "
-                "equal to maxLargestInt");
-  static_assert(Value::minLargestInt / 10 >= -Value::maxLargestInt,
-                "The absolute value of minLargestInt must be only 1 magnitude "
-                "larger than maxLargest Int");
-
-  static constexpr Value::LargestUInt positive_threshold =
-      Value::maxLargestUInt / 10;
-  static constexpr Value::UInt positive_last_digit = Value::maxLargestUInt % 10;
-
-  // For the negative values, we have to be more careful. Since typically
-  // -Value::minLargestInt will cause an overflow, we first divide by 10 and
-  // then take the inverse. This assumes that minLargestInt is only a single
-  // power of 10 different in magnitude, which we check above. For the last
-  // digit, we take the modulus before negating for the same reason.
-  static constexpr auto negative_threshold =
-      Value::LargestUInt(-(Value::minLargestInt / 10));
-  static constexpr auto negative_last_digit =
-      Value::UInt(-(Value::minLargestInt % 10));
-
-  const Value::LargestUInt threshold =
-      isNegative ? negative_threshold : positive_threshold;
-  const Value::UInt max_last_digit =
-      isNegative ? negative_last_digit : positive_last_digit;
-
-  Value::LargestUInt value = 0;
-  while (current < token.end_) {
-    Char c = *current++;
-    if (c < '0' || c > '9')
-      return decodeDouble(token, decoded);
-
-    const auto digit(static_cast<Value::UInt>(c - '0'));
-    if (value >= threshold) {
-      // We've hit or exceeded the max value divided by 10 (rounded down). If
-      // a) we've only just touched the limit, meaing value == threshold,
-      // b) this is the last digit, or
-      // c) it's small enough to fit in that rounding delta, we're okay.
-      // Otherwise treat this number as a double to avoid overflow.
-      if (value > threshold || current != token.end_ ||
-          digit > max_last_digit) {
-        return decodeDouble(token, decoded);
-      }
-    }
-    value = value * 10 + digit;
-  }
-
-  if (isNegative) {
-    // We use the same magnitude assumption here, just in case.
-    const auto last_digit = static_cast<Value::UInt>(value % 10);
-    decoded = -Value::LargestInt(value / 10) * 10 - last_digit;
-  } else if (value <= Value::LargestUInt(Value::maxLargestInt)) {
-    decoded = Value::LargestInt(value);
-  } else {
-    decoded = value;
-  }
-
-  return true;
-}
-
-bool OurReader::decodeDouble(Token& token) {
-  Value decoded;
-  if (!decodeDouble(token, decoded))
-    return false;
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
-  return true;
-}
-
-bool OurReader::decodeDouble(Token& token, Value& decoded) {
-  double value = 0;
-  const String buffer(token.start_, token.end_);
-  IStringStream is(buffer);
-  if (!(is >> value)) {
-    return addError(
-        "'" + String(token.start_, token.end_) + "' is not a number.", token);
-  }
-  decoded = value;
-  return true;
-}
-
-bool OurReader::decodeString(Token& token) {
-  String decoded_string;
-  if (!decodeString(token, decoded_string))
-    return false;
-  Value decoded(decoded_string);
-  currentValue().swapPayload(decoded);
-  currentValue().setOffsetStart(token.start_ - begin_);
-  currentValue().setOffsetLimit(token.end_ - begin_);
-  return true;
-}
-
-bool OurReader::decodeString(Token& token, String& decoded) {
-  decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
-  Location current = token.start_ + 1; // skip '"'
-  Location end = token.end_ - 1;       // do not include '"'
-  while (current != end) {
-    Char c = *current++;
-    if (c == '"')
-      break;
-    if (c == '\\') {
-      if (current == end)
-        return addError("Empty escape sequence in string", token, current);
-      Char escape = *current++;
-      switch (escape) {
-      case '"':
-        decoded += '"';
-        break;
-      case '/':
-        decoded += '/';
-        break;
-      case '\\':
-        decoded += '\\';
-        break;
-      case 'b':
-        decoded += '\b';
-        break;
-      case 'f':
-        decoded += '\f';
-        break;
-      case 'n':
-        decoded += '\n';
-        break;
-      case 'r':
-        decoded += '\r';
-        break;
-      case 't':
-        decoded += '\t';
-        break;
-      case 'u': {
-        unsigned int unicode;
-        if (!decodeUnicodeCodePoint(token, current, end, unicode))
-          return false;
-        decoded += codePointToUTF8(unicode);
-      } break;
-      default:
-        return addError("Bad escape sequence in string", token, current);
-      }
-    } else {
-      decoded += c;
-    }
-  }
-  return true;
-}
-
-bool OurReader::decodeUnicodeCodePoint(Token& token, Location& current,
-                                       Location end, unsigned int& unicode) {
-
-  if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
-    return false;
-  if (unicode >= 0xD800 && unicode <= 0xDBFF) {
-    // surrogate pairs
-    if (end - current < 6)
-      return addError(
-          "additional six characters expected to parse unicode surrogate pair.",
-          token, current);
-    if (*(current++) == '\\' && *(current++) == 'u') {
-      unsigned int surrogatePair;
-      if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
-        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
-      } else
-        return false;
-    } else
-      return addError("expecting another \\u token to begin the second half of "
-                      "a unicode surrogate pair",
-                      token, current);
-  }
-  return true;
-}
-
-bool OurReader::decodeUnicodeEscapeSequence(Token& token, Location& current,
-                                            Location end,
-                                            unsigned int& ret_unicode) {
-  if (end - current < 4)
-    return addError(
-        "Bad unicode escape sequence in string: four digits expected.", token,
-        current);
-  int unicode = 0;
-  for (int index = 0; index < 4; ++index) {
-    Char c = *current++;
-    unicode *= 16;
-    if (c >= '0' && c <= '9')
-      unicode += c - '0';
-    else if (c >= 'a' && c <= 'f')
-      unicode += c - 'a' + 10;
-    else if (c >= 'A' && c <= 'F')
-      unicode += c - 'A' + 10;
-    else
-      return addError(
-          "Bad unicode escape sequence in string: hexadecimal digit expected.",
-          token, current);
-  }
-  ret_unicode = static_cast<unsigned int>(unicode);
-  return true;
-}
-
-bool OurReader::addError(const String& message, Token& token, Location extra) {
-  ErrorInfo info;
-  info.token_ = token;
-  info.message_ = message;
-  info.extra_ = extra;
-  errors_.push_back(info);
-  return false;
-}
-
-bool OurReader::recoverFromError(TokenType skipUntilToken) {
-  size_t errorCount = errors_.size();
-  Token skip;
-  for (;;) {
-    if (!readToken(skip))
-      errors_.resize(errorCount); // discard errors caused by recovery
-    if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
-      break;
-  }
-  errors_.resize(errorCount);
-  return false;
-}
-
-bool OurReader::addErrorAndRecover(const String& message, Token& token,
-                                   TokenType skipUntilToken) {
-  addError(message, token);
-  return recoverFromError(skipUntilToken);
-}
-
-Value& OurReader::currentValue() { return *(nodes_.top()); }
-
-OurReader::Char OurReader::getNextChar() {
-  if (current_ == end_)
-    return 0;
-  return *current_++;
-}
-
-void OurReader::getLocationLineAndColumn(Location location, int& line,
-                                         int& column) const {
-  Location current = begin_;
-  Location lastLineStart = current;
-  line = 0;
-  while (current < location && current != end_) {
-    Char c = *current++;
-    if (c == '\r') {
-      if (*current == '\n')
-        ++current;
-      lastLineStart = current;
-      ++line;
-    } else if (c == '\n') {
-      lastLineStart = current;
-      ++line;
-    }
-  }
-  // column & line start at 1
-  column = int(location - lastLineStart) + 1;
-  ++line;
-}
-
-String OurReader::getLocationLineAndColumn(Location location) const {
-  int line, column;
-  getLocationLineAndColumn(location, line, column);
-  char buffer[18 + 16 + 16 + 1];
-  jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
-  return buffer;
-}
-
-String OurReader::getFormattedErrorMessages() const {
-  String formattedMessage;
-  for (const auto& error : errors_) {
-    formattedMessage +=
-        "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
-    formattedMessage += "  " + error.message_ + "\n";
-    if (error.extra_)
-      formattedMessage +=
-          "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
-  }
-  return formattedMessage;
-}
-
-std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
-  std::vector<OurReader::StructuredError> allErrors;
-  for (const auto& error : errors_) {
-    OurReader::StructuredError structured;
-    structured.offset_start = error.token_.start_ - begin_;
-    structured.offset_limit = error.token_.end_ - begin_;
-    structured.message = error.message_;
-    allErrors.push_back(structured);
-  }
-  return allErrors;
-}
-
-class OurCharReader : public CharReader {
-  bool const collectComments_;
-  OurReader reader_;
-
-public:
-  OurCharReader(bool collectComments, OurFeatures const& features)
-      : collectComments_(collectComments), reader_(features) {}
-  bool parse(char const* beginDoc, char const* endDoc, Value* root,
-             String* errs) override {
-    bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
-    if (errs) {
-      *errs = reader_.getFormattedErrorMessages();
-    }
-    return ok;
-  }
-};
-
-CharReaderBuilder::CharReaderBuilder() { setDefaults(&settings_); }
-CharReaderBuilder::~CharReaderBuilder() = default;
-CharReader* CharReaderBuilder::newCharReader() const {
-  bool collectComments = settings_["collectComments"].asBool();
-  OurFeatures features = OurFeatures::all();
-  features.allowComments_ = settings_["allowComments"].asBool();
-  features.allowTrailingCommas_ = settings_["allowTrailingCommas"].asBool();
-  features.strictRoot_ = settings_["strictRoot"].asBool();
-  features.allowDroppedNullPlaceholders_ =
-      settings_["allowDroppedNullPlaceholders"].asBool();
-  features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool();
-  features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool();
-
-  // Stack limit is always a size_t, so we get this as an unsigned int
-  // regardless of it we have 64-bit integer support enabled.
-  features.stackLimit_ = static_cast<size_t>(settings_["stackLimit"].asUInt());
-  features.failIfExtra_ = settings_["failIfExtra"].asBool();
-  features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool();
-  features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool();
-  features.skipBom_ = settings_["skipBom"].asBool();
-  return new OurCharReader(collectComments, features);
-}
-
-bool CharReaderBuilder::validate(Json::Value* invalid) const {
-  static const auto& valid_keys = *new std::set<String>{
-      "collectComments",
-      "allowComments",
-      "allowTrailingCommas",
-      "strictRoot",
-      "allowDroppedNullPlaceholders",
-      "allowNumericKeys",
-      "allowSingleQuotes",
-      "stackLimit",
-      "failIfExtra",
-      "rejectDupKeys",
-      "allowSpecialFloats",
-      "skipBom",
-  };
-  for (auto si = settings_.begin(); si != settings_.end(); ++si) {
-    auto key = si.name();
-    if (valid_keys.count(key))
-      continue;
-    if (invalid)
-      (*invalid)[key] = *si;
-    else
-      return false;
-  }
-  return invalid ? invalid->empty() : true;
-}
-
-Value& CharReaderBuilder::operator[](const String& key) {
-  return settings_[key];
-}
-// static
-void CharReaderBuilder::strictMode(Json::Value* settings) {
-  //! [CharReaderBuilderStrictMode]
-  (*settings)["allowComments"] = false;
-  (*settings)["allowTrailingCommas"] = false;
-  (*settings)["strictRoot"] = true;
-  (*settings)["allowDroppedNullPlaceholders"] = false;
-  (*settings)["allowNumericKeys"] = false;
-  (*settings)["allowSingleQuotes"] = false;
-  (*settings)["stackLimit"] = 1000;
-  (*settings)["failIfExtra"] = true;
-  (*settings)["rejectDupKeys"] = true;
-  (*settings)["allowSpecialFloats"] = false;
-  (*settings)["skipBom"] = true;
-  //! [CharReaderBuilderStrictMode]
-}
-// static
-void CharReaderBuilder::setDefaults(Json::Value* settings) {
-  //! [CharReaderBuilderDefaults]
-  (*settings)["collectComments"] = true;
-  (*settings)["allowComments"] = true;
-  (*settings)["allowTrailingCommas"] = true;
-  (*settings)["strictRoot"] = false;
-  (*settings)["allowDroppedNullPlaceholders"] = false;
-  (*settings)["allowNumericKeys"] = false;
-  (*settings)["allowSingleQuotes"] = false;
-  (*settings)["stackLimit"] = 1000;
-  (*settings)["failIfExtra"] = false;
-  (*settings)["rejectDupKeys"] = false;
-  (*settings)["allowSpecialFloats"] = false;
-  (*settings)["skipBom"] = true;
-  //! [CharReaderBuilderDefaults]
-}
-
-//////////////////////////////////
-// global functions
-
-bool parseFromStream(CharReader::Factory const& fact, IStream& sin, Value* root,
-                     String* errs) {
-  OStringStream ssin;
-  ssin << sin.rdbuf();
-  String doc = ssin.str();
-  char const* begin = doc.data();
-  char const* end = begin + doc.size();
-  // Note that we do not actually need a null-terminator.
-  CharReaderPtr const reader(fact.newCharReader());
-  return reader->parse(begin, end, root, errs);
-}
-
-IStream& operator>>(IStream& sin, Value& root) {
-  CharReaderBuilder b;
-  String errs;
-  bool ok = parseFromStream(b, sin, &root, &errs);
-  if (!ok) {
-    throwRuntimeError(errs);
-  }
-  return sin;
-}
-
-} // namespace Json
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: src/lib_json/json_reader.cpp
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: src/lib_json/json_valueiterator.inl
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-// included by json_value.cpp
-
-namespace Json {
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class ValueIteratorBase
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-ValueIteratorBase::ValueIteratorBase() : current_() {}
-
-ValueIteratorBase::ValueIteratorBase(
-    const Value::ObjectValues::iterator& current)
-    : current_(current), isNull_(false) {}
-
-Value& ValueIteratorBase::deref() { return current_->second; }
-const Value& ValueIteratorBase::deref() const { return current_->second; }
-
-void ValueIteratorBase::increment() { ++current_; }
-
-void ValueIteratorBase::decrement() { --current_; }
-
-ValueIteratorBase::difference_type
-ValueIteratorBase::computeDistance(const SelfType& other) const {
-  // Iterator for null value are initialized using the default
-  // constructor, which initialize current_ to the default
-  // std::map::iterator. As begin() and end() are two instance
-  // of the default std::map::iterator, they can not be compared.
-  // To allow this, we handle this comparison specifically.
-  if (isNull_ && other.isNull_) {
-    return 0;
-  }
-
-  // Usage of std::distance is not portable (does not compile with Sun Studio 12
-  // RogueWave STL,
-  // which is the one used by default).
-  // Using a portable hand-made version for non random iterator instead:
-  //   return difference_type( std::distance( current_, other.current_ ) );
-  difference_type myDistance = 0;
-  for (Value::ObjectValues::iterator it = current_; it != other.current_;
-       ++it) {
-    ++myDistance;
-  }
-  return myDistance;
-}
-
-bool ValueIteratorBase::isEqual(const SelfType& other) const {
-  if (isNull_) {
-    return other.isNull_;
-  }
-  return current_ == other.current_;
-}
-
-void ValueIteratorBase::copy(const SelfType& other) {
-  current_ = other.current_;
-  isNull_ = other.isNull_;
-}
-
-Value ValueIteratorBase::key() const {
-  const Value::CZString czstring = (*current_).first;
-  if (czstring.data()) {
-    if (czstring.isStaticString())
-      return Value(StaticString(czstring.data()));
-    return Value(czstring.data(), czstring.data() + czstring.length());
-  }
-  return Value(czstring.index());
-}
-
-UInt ValueIteratorBase::index() const {
-  const Value::CZString czstring = (*current_).first;
-  if (!czstring.data())
-    return czstring.index();
-  return Value::UInt(-1);
-}
-
-String ValueIteratorBase::name() const {
-  char const* keey;
-  char const* end;
-  keey = memberName(&end);
-  if (!keey)
-    return String();
-  return String(keey, end);
-}
-
-char const* ValueIteratorBase::memberName() const {
-  const char* cname = (*current_).first.data();
-  return cname ? cname : "";
-}
-
-char const* ValueIteratorBase::memberName(char const** end) const {
-  const char* cname = (*current_).first.data();
-  if (!cname) {
-    *end = nullptr;
-    return nullptr;
-  }
-  *end = cname + (*current_).first.length();
-  return cname;
-}
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class ValueConstIterator
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-ValueConstIterator::ValueConstIterator() = default;
-
-ValueConstIterator::ValueConstIterator(
-    const Value::ObjectValues::iterator& current)
-    : ValueIteratorBase(current) {}
-
-ValueConstIterator::ValueConstIterator(ValueIterator const& other)
-    : ValueIteratorBase(other) {}
-
-ValueConstIterator& ValueConstIterator::
-operator=(const ValueIteratorBase& other) {
-  copy(other);
-  return *this;
-}
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class ValueIterator
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-ValueIterator::ValueIterator() = default;
-
-ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
-    : ValueIteratorBase(current) {}
-
-ValueIterator::ValueIterator(const ValueConstIterator& other)
-    : ValueIteratorBase(other) {
-  throwRuntimeError("ConstIterator to Iterator should never be allowed.");
-}
-
-ValueIterator::ValueIterator(const ValueIterator& other) = default;
-
-ValueIterator& ValueIterator::operator=(const SelfType& other) {
-  copy(other);
-  return *this;
-}
-
-} // namespace Json
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: src/lib_json/json_valueiterator.inl
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: src/lib_json/json_value.cpp
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include <json/assertions.h>
-#include <json/value.h>
-#include <json/writer.h>
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <cstddef>
-#include <cstring>
-#include <iostream>
-#include <sstream>
-#include <utility>
-
-// Provide implementation equivalent of std::snprintf for older _MSC compilers
-#if defined(_MSC_VER) && _MSC_VER < 1900
-#include <stdarg.h>
-static int msvc_pre1900_c99_vsnprintf(char* outBuf, size_t size,
-                                      const char* format, va_list ap) {
-  int count = -1;
-  if (size != 0)
-    count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
-  if (count == -1)
-    count = _vscprintf(format, ap);
-  return count;
-}
-
-int JSON_API msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
-                                       const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  const int count = msvc_pre1900_c99_vsnprintf(outBuf, size, format, ap);
-  va_end(ap);
-  return count;
-}
-#endif
-
-// Disable warning C4702 : unreachable code
-#if defined(_MSC_VER)
-#pragma warning(disable : 4702)
-#endif
-
-#define JSON_ASSERT_UNREACHABLE assert(false)
-
-namespace Json {
-template <typename T>
-static std::unique_ptr<T> cloneUnique(const std::unique_ptr<T>& p) {
-  std::unique_ptr<T> r;
-  if (p) {
-    r = std::unique_ptr<T>(new T(*p));
-  }
-  return r;
-}
-
-// This is a walkaround to avoid the static initialization of Value::null.
-// kNull must be word-aligned to avoid crashing on ARM.  We use an alignment of
-// 8 (instead of 4) as a bit of future-proofing.
-#if defined(__ARMEL__)
-#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
-#else
-#define ALIGNAS(byte_alignment)
-#endif
-
-// static
-Value const& Value::nullSingleton() {
-  static Value const nullStatic;
-  return nullStatic;
-}
-
-#if JSON_USE_NULLREF
-// for backwards compatibility, we'll leave these global references around, but
-// DO NOT use them in JSONCPP library code any more!
-// static
-Value const& Value::null = Value::nullSingleton();
-
-// static
-Value const& Value::nullRef = Value::nullSingleton();
-#endif
-
-#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-template <typename T, typename U>
-static inline bool InRange(double d, T min, U max) {
-  // The casts can lose precision, but we are looking only for
-  // an approximate range. Might fail on edge cases though. ~cdunn
-  return d >= static_cast<double>(min) && d <= static_cast<double>(max);
-}
-#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-static inline double integerToDouble(Json::UInt64 value) {
-  return static_cast<double>(Int64(value / 2)) * 2.0 +
-         static_cast<double>(Int64(value & 1));
-}
-
-template <typename T> static inline double integerToDouble(T value) {
-  return static_cast<double>(value);
-}
-
-template <typename T, typename U>
-static inline bool InRange(double d, T min, U max) {
-  return d >= integerToDouble(min) && d <= integerToDouble(max);
-}
-#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-
-/** Duplicates the specified string value.
- * @param value Pointer to the string to duplicate. Must be zero-terminated if
- *              length is "unknown".
- * @param length Length of the value. if equals to unknown, then it will be
- *               computed using strlen(value).
- * @return Pointer on the duplicate instance of string.
- */
-static inline char* duplicateStringValue(const char* value, size_t length) {
-  // Avoid an integer overflow in the call to malloc below by limiting length
-  // to a sane value.
-  if (length >= static_cast<size_t>(Value::maxInt))
-    length = Value::maxInt - 1;
-
-  auto newString = static_cast<char*>(malloc(length + 1));
-  if (newString == nullptr) {
-    throwRuntimeError("in Json::Value::duplicateStringValue(): "
-                      "Failed to allocate string value buffer");
-  }
-  memcpy(newString, value, length);
-  newString[length] = 0;
-  return newString;
-}
-
-/* Record the length as a prefix.
- */
-static inline char* duplicateAndPrefixStringValue(const char* value,
-                                                  unsigned int length) {
-  // Avoid an integer overflow in the call to malloc below by limiting length
-  // to a sane value.
-  JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) -
-                                    sizeof(unsigned) - 1U,
-                      "in Json::Value::duplicateAndPrefixStringValue(): "
-                      "length too big for prefixing");
-  size_t actualLength = sizeof(length) + length + 1;
-  auto newString = static_cast<char*>(malloc(actualLength));
-  if (newString == nullptr) {
-    throwRuntimeError("in Json::Value::duplicateAndPrefixStringValue(): "
-                      "Failed to allocate string value buffer");
-  }
-  *reinterpret_cast<unsigned*>(newString) = length;
-  memcpy(newString + sizeof(unsigned), value, length);
-  newString[actualLength - 1U] =
-      0; // to avoid buffer over-run accidents by users later
-  return newString;
-}
-inline static void decodePrefixedString(bool isPrefixed, char const* prefixed,
-                                        unsigned* length, char const** value) {
-  if (!isPrefixed) {
-    *length = static_cast<unsigned>(strlen(prefixed));
-    *value = prefixed;
-  } else {
-    *length = *reinterpret_cast<unsigned const*>(prefixed);
-    *value = prefixed + sizeof(unsigned);
-  }
-}
-/** Free the string duplicated by
- * duplicateStringValue()/duplicateAndPrefixStringValue().
- */
-#if JSONCPP_USING_SECURE_MEMORY
-static inline void releasePrefixedStringValue(char* value) {
-  unsigned length = 0;
-  char const* valueDecoded;
-  decodePrefixedString(true, value, &length, &valueDecoded);
-  size_t const size = sizeof(unsigned) + length + 1U;
-  memset(value, 0, size);
-  free(value);
-}
-static inline void releaseStringValue(char* value, unsigned length) {
-  // length==0 => we allocated the strings memory
-  size_t size = (length == 0) ? strlen(value) : length;
-  memset(value, 0, size);
-  free(value);
-}
-#else  // !JSONCPP_USING_SECURE_MEMORY
-static inline void releasePrefixedStringValue(char* value) { free(value); }
-static inline void releaseStringValue(char* value, unsigned) { free(value); }
-#endif // JSONCPP_USING_SECURE_MEMORY
-
-} // namespace Json
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// ValueInternals...
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-#if !defined(JSON_IS_AMALGAMATION)
-
-#include "json_valueiterator.inl"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-namespace Json {
-
-#if JSON_USE_EXCEPTION
-Exception::Exception(String msg) : msg_(std::move(msg)) {}
-Exception::~Exception() noexcept = default;
-char const* Exception::what() const noexcept { return msg_.c_str(); }
-RuntimeError::RuntimeError(String const& msg) : Exception(msg) {}
-LogicError::LogicError(String const& msg) : Exception(msg) {}
-JSONCPP_NORETURN void throwRuntimeError(String const& msg) {
-  throw RuntimeError(msg);
-}
-JSONCPP_NORETURN void throwLogicError(String const& msg) {
-  throw LogicError(msg);
-}
-#else // !JSON_USE_EXCEPTION
-JSONCPP_NORETURN void throwRuntimeError(String const& msg) {
-  std::cerr << msg << std::endl;
-  abort();
-}
-JSONCPP_NORETURN void throwLogicError(String const& msg) {
-  std::cerr << msg << std::endl;
-  abort();
-}
-#endif
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class Value::CZString
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-// Notes: policy_ indicates if the string was allocated when
-// a string is stored.
-
-Value::CZString::CZString(ArrayIndex index) : cstr_(nullptr), index_(index) {}
-
-Value::CZString::CZString(char const* str, unsigned length,
-                          DuplicationPolicy allocate)
-    : cstr_(str) {
-  // allocate != duplicate
-  storage_.policy_ = allocate & 0x3;
-  storage_.length_ = length & 0x3FFFFFFF;
-}
-
-Value::CZString::CZString(const CZString& other) {
-  cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != nullptr
-               ? duplicateStringValue(other.cstr_, other.storage_.length_)
-               : other.cstr_);
-  storage_.policy_ =
-      static_cast<unsigned>(
-          other.cstr_
-              ? (static_cast<DuplicationPolicy>(other.storage_.policy_) ==
-                         noDuplication
-                     ? noDuplication
-                     : duplicate)
-              : static_cast<DuplicationPolicy>(other.storage_.policy_)) &
-      3U;
-  storage_.length_ = other.storage_.length_;
-}
-
-Value::CZString::CZString(CZString&& other) noexcept
-    : cstr_(other.cstr_), index_(other.index_) {
-  other.cstr_ = nullptr;
-}
-
-Value::CZString::~CZString() {
-  if (cstr_ && storage_.policy_ == duplicate) {
-    releaseStringValue(const_cast<char*>(cstr_),
-                       storage_.length_ + 1U); // +1 for null terminating
-                                               // character for sake of
-                                               // completeness but not actually
-                                               // necessary
-  }
-}
-
-void Value::CZString::swap(CZString& other) {
-  std::swap(cstr_, other.cstr_);
-  std::swap(index_, other.index_);
-}
-
-Value::CZString& Value::CZString::operator=(const CZString& other) {
-  cstr_ = other.cstr_;
-  index_ = other.index_;
-  return *this;
-}
-
-Value::CZString& Value::CZString::operator=(CZString&& other) noexcept {
-  cstr_ = other.cstr_;
-  index_ = other.index_;
-  other.cstr_ = nullptr;
-  return *this;
-}
-
-bool Value::CZString::operator<(const CZString& other) const {
-  if (!cstr_)
-    return index_ < other.index_;
-  // return strcmp(cstr_, other.cstr_) < 0;
-  // Assume both are strings.
-  unsigned this_len = this->storage_.length_;
-  unsigned other_len = other.storage_.length_;
-  unsigned min_len = std::min<unsigned>(this_len, other_len);
-  JSON_ASSERT(this->cstr_ && other.cstr_);
-  int comp = memcmp(this->cstr_, other.cstr_, min_len);
-  if (comp < 0)
-    return true;
-  if (comp > 0)
-    return false;
-  return (this_len < other_len);
-}
-
-bool Value::CZString::operator==(const CZString& other) const {
-  if (!cstr_)
-    return index_ == other.index_;
-  // return strcmp(cstr_, other.cstr_) == 0;
-  // Assume both are strings.
-  unsigned this_len = this->storage_.length_;
-  unsigned other_len = other.storage_.length_;
-  if (this_len != other_len)
-    return false;
-  JSON_ASSERT(this->cstr_ && other.cstr_);
-  int comp = memcmp(this->cstr_, other.cstr_, this_len);
-  return comp == 0;
-}
-
-ArrayIndex Value::CZString::index() const { return index_; }
-
-// const char* Value::CZString::c_str() const { return cstr_; }
-const char* Value::CZString::data() const { return cstr_; }
-unsigned Value::CZString::length() const { return storage_.length_; }
-bool Value::CZString::isStaticString() const {
-  return storage_.policy_ == noDuplication;
-}
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class Value::Value
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-/*! \internal Default constructor initialization must be equivalent to:
- * memset( this, 0, sizeof(Value) )
- * This optimization is used in ValueInternalMap fast allocator.
- */
-Value::Value(ValueType type) {
-  static char const emptyString[] = "";
-  initBasic(type);
-  switch (type) {
-  case nullValue:
-    break;
-  case intValue:
-  case uintValue:
-    value_.int_ = 0;
-    break;
-  case realValue:
-    value_.real_ = 0.0;
-    break;
-  case stringValue:
-    // allocated_ == false, so this is safe.
-    value_.string_ = const_cast<char*>(static_cast<char const*>(emptyString));
-    break;
-  case arrayValue:
-  case objectValue:
-    value_.map_ = new ObjectValues();
-    break;
-  case booleanValue:
-    value_.bool_ = false;
-    break;
-  default:
-    JSON_ASSERT_UNREACHABLE;
-  }
-}
-
-Value::Value(Int value) {
-  initBasic(intValue);
-  value_.int_ = value;
-}
-
-Value::Value(UInt value) {
-  initBasic(uintValue);
-  value_.uint_ = value;
-}
-#if defined(JSON_HAS_INT64)
-Value::Value(Int64 value) {
-  initBasic(intValue);
-  value_.int_ = value;
-}
-Value::Value(UInt64 value) {
-  initBasic(uintValue);
-  value_.uint_ = value;
-}
-#endif // defined(JSON_HAS_INT64)
-
-Value::Value(double value) {
-  initBasic(realValue);
-  value_.real_ = value;
-}
-
-Value::Value(const char* value) {
-  initBasic(stringValue, true);
-  JSON_ASSERT_MESSAGE(value != nullptr,
-                      "Null Value Passed to Value Constructor");
-  value_.string_ = duplicateAndPrefixStringValue(
-      value, static_cast<unsigned>(strlen(value)));
-}
-
-Value::Value(const char* begin, const char* end) {
-  initBasic(stringValue, true);
-  value_.string_ =
-      duplicateAndPrefixStringValue(begin, static_cast<unsigned>(end - begin));
-}
-
-Value::Value(const String& value) {
-  initBasic(stringValue, true);
-  value_.string_ = duplicateAndPrefixStringValue(
-      value.data(), static_cast<unsigned>(value.length()));
-}
-
-Value::Value(const StaticString& value) {
-  initBasic(stringValue);
-  value_.string_ = const_cast<char*>(value.c_str());
-}
-
-Value::Value(bool value) {
-  initBasic(booleanValue);
-  value_.bool_ = value;
-}
-
-Value::Value(const Value& other) {
-  dupPayload(other);
-  dupMeta(other);
-}
-
-Value::Value(Value&& other) noexcept {
-  initBasic(nullValue);
-  swap(other);
-}
-
-Value::~Value() {
-  releasePayload();
-  value_.uint_ = 0;
-}
-
-Value& Value::operator=(const Value& other) {
-  Value(other).swap(*this);
-  return *this;
-}
-
-Value& Value::operator=(Value&& other) noexcept {
-  other.swap(*this);
-  return *this;
-}
-
-void Value::swapPayload(Value& other) {
-  std::swap(bits_, other.bits_);
-  std::swap(value_, other.value_);
-}
-
-void Value::copyPayload(const Value& other) {
-  releasePayload();
-  dupPayload(other);
-}
-
-void Value::swap(Value& other) {
-  swapPayload(other);
-  std::swap(comments_, other.comments_);
-  std::swap(start_, other.start_);
-  std::swap(limit_, other.limit_);
-}
-
-void Value::copy(const Value& other) {
-  copyPayload(other);
-  dupMeta(other);
-}
-
-ValueType Value::type() const {
-  return static_cast<ValueType>(bits_.value_type_);
-}
-
-int Value::compare(const Value& other) const {
-  if (*this < other)
-    return -1;
-  if (*this > other)
-    return 1;
-  return 0;
-}
-
-bool Value::operator<(const Value& other) const {
-  int typeDelta = type() - other.type();
-  if (typeDelta)
-    return typeDelta < 0;
-  switch (type()) {
-  case nullValue:
-    return false;
-  case intValue:
-    return value_.int_ < other.value_.int_;
-  case uintValue:
-    return value_.uint_ < other.value_.uint_;
-  case realValue:
-    return value_.real_ < other.value_.real_;
-  case booleanValue:
-    return value_.bool_ < other.value_.bool_;
-  case stringValue: {
-    if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) {
-      return other.value_.string_ != nullptr;
-    }
-    unsigned this_len;
-    unsigned other_len;
-    char const* this_str;
-    char const* other_str;
-    decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
-                         &this_str);
-    decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len,
-                         &other_str);
-    unsigned min_len = std::min<unsigned>(this_len, other_len);
-    JSON_ASSERT(this_str && other_str);
-    int comp = memcmp(this_str, other_str, min_len);
-    if (comp < 0)
-      return true;
-    if (comp > 0)
-      return false;
-    return (this_len < other_len);
-  }
-  case arrayValue:
-  case objectValue: {
-    auto thisSize = value_.map_->size();
-    auto otherSize = other.value_.map_->size();
-    if (thisSize != otherSize)
-      return thisSize < otherSize;
-    return (*value_.map_) < (*other.value_.map_);
-  }
-  default:
-    JSON_ASSERT_UNREACHABLE;
-  }
-  return false; // unreachable
-}
-
-bool Value::operator<=(const Value& other) const { return !(other < *this); }
-
-bool Value::operator>=(const Value& other) const { return !(*this < other); }
-
-bool Value::operator>(const Value& other) const { return other < *this; }
-
-bool Value::operator==(const Value& other) const {
-  if (type() != other.type())
-    return false;
-  switch (type()) {
-  case nullValue:
-    return true;
-  case intValue:
-    return value_.int_ == other.value_.int_;
-  case uintValue:
-    return value_.uint_ == other.value_.uint_;
-  case realValue:
-    return value_.real_ == other.value_.real_;
-  case booleanValue:
-    return value_.bool_ == other.value_.bool_;
-  case stringValue: {
-    if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) {
-      return (value_.string_ == other.value_.string_);
-    }
-    unsigned this_len;
-    unsigned other_len;
-    char const* this_str;
-    char const* other_str;
-    decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
-                         &this_str);
-    decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len,
-                         &other_str);
-    if (this_len != other_len)
-      return false;
-    JSON_ASSERT(this_str && other_str);
-    int comp = memcmp(this_str, other_str, this_len);
-    return comp == 0;
-  }
-  case arrayValue:
-  case objectValue:
-    return value_.map_->size() == other.value_.map_->size() &&
-           (*value_.map_) == (*other.value_.map_);
-  default:
-    JSON_ASSERT_UNREACHABLE;
-  }
-  return false; // unreachable
-}
-
-bool Value::operator!=(const Value& other) const { return !(*this == other); }
-
-const char* Value::asCString() const {
-  JSON_ASSERT_MESSAGE(type() == stringValue,
-                      "in Json::Value::asCString(): requires stringValue");
-  if (value_.string_ == nullptr)
-    return nullptr;
-  unsigned this_len;
-  char const* this_str;
-  decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
-                       &this_str);
-  return this_str;
-}
-
-#if JSONCPP_USING_SECURE_MEMORY
-unsigned Value::getCStringLength() const {
-  JSON_ASSERT_MESSAGE(type() == stringValue,
-                      "in Json::Value::asCString(): requires stringValue");
-  if (value_.string_ == 0)
-    return 0;
-  unsigned this_len;
-  char const* this_str;
-  decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
-                       &this_str);
-  return this_len;
-}
-#endif
-
-bool Value::getString(char const** begin, char const** end) const {
-  if (type() != stringValue)
-    return false;
-  if (value_.string_ == nullptr)
-    return false;
-  unsigned length;
-  decodePrefixedString(this->isAllocated(), this->value_.string_, &length,
-                       begin);
-  *end = *begin + length;
-  return true;
-}
-
-String Value::asString() const {
-  switch (type()) {
-  case nullValue:
-    return "";
-  case stringValue: {
-    if (value_.string_ == nullptr)
-      return "";
-    unsigned this_len;
-    char const* this_str;
-    decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len,
-                         &this_str);
-    return String(this_str, this_len);
-  }
-  case booleanValue:
-    return value_.bool_ ? "true" : "false";
-  case intValue:
-    return valueToString(value_.int_);
-  case uintValue:
-    return valueToString(value_.uint_);
-  case realValue:
-    return valueToString(value_.real_);
-  default:
-    JSON_FAIL_MESSAGE("Type is not convertible to string");
-  }
-}
-
-Value::Int Value::asInt() const {
-  switch (type()) {
-  case intValue:
-    JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
-    return Int(value_.int_);
-  case uintValue:
-    JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
-    return Int(value_.uint_);
-  case realValue:
-    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
-                        "double out of Int range");
-    return Int(value_.real_);
-  case nullValue:
-    return 0;
-  case booleanValue:
-    return value_.bool_ ? 1 : 0;
-  default:
-    break;
-  }
-  JSON_FAIL_MESSAGE("Value is not convertible to Int.");
-}
-
-Value::UInt Value::asUInt() const {
-  switch (type()) {
-  case intValue:
-    JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
-    return UInt(value_.int_);
-  case uintValue:
-    JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
-    return UInt(value_.uint_);
-  case realValue:
-    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
-                        "double out of UInt range");
-    return UInt(value_.real_);
-  case nullValue:
-    return 0;
-  case booleanValue:
-    return value_.bool_ ? 1 : 0;
-  default:
-    break;
-  }
-  JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
-}
-
-#if defined(JSON_HAS_INT64)
-
-Value::Int64 Value::asInt64() const {
-  switch (type()) {
-  case intValue:
-    return Int64(value_.int_);
-  case uintValue:
-    JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
-    return Int64(value_.uint_);
-  case realValue:
-    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
-                        "double out of Int64 range");
-    return Int64(value_.real_);
-  case nullValue:
-    return 0;
-  case booleanValue:
-    return value_.bool_ ? 1 : 0;
-  default:
-    break;
-  }
-  JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
-}
-
-Value::UInt64 Value::asUInt64() const {
-  switch (type()) {
-  case intValue:
-    JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
-    return UInt64(value_.int_);
-  case uintValue:
-    return UInt64(value_.uint_);
-  case realValue:
-    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
-                        "double out of UInt64 range");
-    return UInt64(value_.real_);
-  case nullValue:
-    return 0;
-  case booleanValue:
-    return value_.bool_ ? 1 : 0;
-  default:
-    break;
-  }
-  JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
-}
-#endif // if defined(JSON_HAS_INT64)
-
-LargestInt Value::asLargestInt() const {
-#if defined(JSON_NO_INT64)
-  return asInt();
-#else
-  return asInt64();
-#endif
-}
-
-LargestUInt Value::asLargestUInt() const {
-#if defined(JSON_NO_INT64)
-  return asUInt();
-#else
-  return asUInt64();
-#endif
-}
-
-double Value::asDouble() const {
-  switch (type()) {
-  case intValue:
-    return static_cast<double>(value_.int_);
-  case uintValue:
-#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-    return static_cast<double>(value_.uint_);
-#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-    return integerToDouble(value_.uint_);
-#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-  case realValue:
-    return value_.real_;
-  case nullValue:
-    return 0.0;
-  case booleanValue:
-    return value_.bool_ ? 1.0 : 0.0;
-  default:
-    break;
-  }
-  JSON_FAIL_MESSAGE("Value is not convertible to double.");
-}
-
-float Value::asFloat() const {
-  switch (type()) {
-  case intValue:
-    return static_cast<float>(value_.int_);
-  case uintValue:
-#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-    return static_cast<float>(value_.uint_);
-#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-    // This can fail (silently?) if the value is bigger than MAX_FLOAT.
-    return static_cast<float>(integerToDouble(value_.uint_));
-#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-  case realValue:
-    return static_cast<float>(value_.real_);
-  case nullValue:
-    return 0.0;
-  case booleanValue:
-    return value_.bool_ ? 1.0F : 0.0F;
-  default:
-    break;
-  }
-  JSON_FAIL_MESSAGE("Value is not convertible to float.");
-}
-
-bool Value::asBool() const {
-  switch (type()) {
-  case booleanValue:
-    return value_.bool_;
-  case nullValue:
-    return false;
-  case intValue:
-    return value_.int_ != 0;
-  case uintValue:
-    return value_.uint_ != 0;
-  case realValue: {
-    // According to JavaScript language zero or NaN is regarded as false
-    const auto value_classification = std::fpclassify(value_.real_);
-    return value_classification != FP_ZERO && value_classification != FP_NAN;
-  }
-  default:
-    break;
-  }
-  JSON_FAIL_MESSAGE("Value is not convertible to bool.");
-}
-
-bool Value::isConvertibleTo(ValueType other) const {
-  switch (other) {
-  case nullValue:
-    return (isNumeric() && asDouble() == 0.0) ||
-           (type() == booleanValue && !value_.bool_) ||
-           (type() == stringValue && asString().empty()) ||
-           (type() == arrayValue && value_.map_->empty()) ||
-           (type() == objectValue && value_.map_->empty()) ||
-           type() == nullValue;
-  case intValue:
-    return isInt() ||
-           (type() == realValue && InRange(value_.real_, minInt, maxInt)) ||
-           type() == booleanValue || type() == nullValue;
-  case uintValue:
-    return isUInt() ||
-           (type() == realValue && InRange(value_.real_, 0, maxUInt)) ||
-           type() == booleanValue || type() == nullValue;
-  case realValue:
-    return isNumeric() || type() == booleanValue || type() == nullValue;
-  case booleanValue:
-    return isNumeric() || type() == booleanValue || type() == nullValue;
-  case stringValue:
-    return isNumeric() || type() == booleanValue || type() == stringValue ||
-           type() == nullValue;
-  case arrayValue:
-    return type() == arrayValue || type() == nullValue;
-  case objectValue:
-    return type() == objectValue || type() == nullValue;
-  }
-  JSON_ASSERT_UNREACHABLE;
-  return false;
-}
-
-/// Number of values in array or object
-ArrayIndex Value::size() const {
-  switch (type()) {
-  case nullValue:
-  case intValue:
-  case uintValue:
-  case realValue:
-  case booleanValue:
-  case stringValue:
-    return 0;
-  case arrayValue: // size of the array is highest index + 1
-    if (!value_.map_->empty()) {
-      ObjectValues::const_iterator itLast = value_.map_->end();
-      --itLast;
-      return (*itLast).first.index() + 1;
-    }
-    return 0;
-  case objectValue:
-    return ArrayIndex(value_.map_->size());
-  }
-  JSON_ASSERT_UNREACHABLE;
-  return 0; // unreachable;
-}
-
-bool Value::empty() const {
-  if (isNull() || isArray() || isObject())
-    return size() == 0U;
-  return false;
-}
-
-Value::operator bool() const { return !isNull(); }
-
-void Value::clear() {
-  JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue ||
-                          type() == objectValue,
-                      "in Json::Value::clear(): requires complex value");
-  start_ = 0;
-  limit_ = 0;
-  switch (type()) {
-  case arrayValue:
-  case objectValue:
-    value_.map_->clear();
-    break;
-  default:
-    break;
-  }
-}
-
-void Value::resize(ArrayIndex newSize) {
-  JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
-                      "in Json::Value::resize(): requires arrayValue");
-  if (type() == nullValue)
-    *this = Value(arrayValue);
-  ArrayIndex oldSize = size();
-  if (newSize == 0)
-    clear();
-  else if (newSize > oldSize)
-    for (ArrayIndex i = oldSize; i < newSize; ++i)
-      (*this)[i];
-  else {
-    for (ArrayIndex index = newSize; index < oldSize; ++index) {
-      value_.map_->erase(index);
-    }
-    JSON_ASSERT(size() == newSize);
-  }
-}
-
-Value& Value::operator[](ArrayIndex index) {
-  JSON_ASSERT_MESSAGE(
-      type() == nullValue || type() == arrayValue,
-      "in Json::Value::operator[](ArrayIndex): requires arrayValue");
-  if (type() == nullValue)
-    *this = Value(arrayValue);
-  CZString key(index);
-  auto it = value_.map_->lower_bound(key);
-  if (it != value_.map_->end() && (*it).first == key)
-    return (*it).second;
-
-  ObjectValues::value_type defaultValue(key, nullSingleton());
-  it = value_.map_->insert(it, defaultValue);
-  return (*it).second;
-}
-
-Value& Value::operator[](int index) {
-  JSON_ASSERT_MESSAGE(
-      index >= 0,
-      "in Json::Value::operator[](int index): index cannot be negative");
-  return (*this)[ArrayIndex(index)];
-}
-
-const Value& Value::operator[](ArrayIndex index) const {
-  JSON_ASSERT_MESSAGE(
-      type() == nullValue || type() == arrayValue,
-      "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
-  if (type() == nullValue)
-    return nullSingleton();
-  CZString key(index);
-  ObjectValues::const_iterator it = value_.map_->find(key);
-  if (it == value_.map_->end())
-    return nullSingleton();
-  return (*it).second;
-}
-
-const Value& Value::operator[](int index) const {
-  JSON_ASSERT_MESSAGE(
-      index >= 0,
-      "in Json::Value::operator[](int index) const: index cannot be negative");
-  return (*this)[ArrayIndex(index)];
-}
-
-void Value::initBasic(ValueType type, bool allocated) {
-  setType(type);
-  setIsAllocated(allocated);
-  comments_ = Comments{};
-  start_ = 0;
-  limit_ = 0;
-}
-
-void Value::dupPayload(const Value& other) {
-  setType(other.type());
-  setIsAllocated(false);
-  switch (type()) {
-  case nullValue:
-  case intValue:
-  case uintValue:
-  case realValue:
-  case booleanValue:
-    value_ = other.value_;
-    break;
-  case stringValue:
-    if (other.value_.string_ && other.isAllocated()) {
-      unsigned len;
-      char const* str;
-      decodePrefixedString(other.isAllocated(), other.value_.string_, &len,
-                           &str);
-      value_.string_ = duplicateAndPrefixStringValue(str, len);
-      setIsAllocated(true);
-    } else {
-      value_.string_ = other.value_.string_;
-    }
-    break;
-  case arrayValue:
-  case objectValue:
-    value_.map_ = new ObjectValues(*other.value_.map_);
-    break;
-  default:
-    JSON_ASSERT_UNREACHABLE;
-  }
-}
-
-void Value::releasePayload() {
-  switch (type()) {
-  case nullValue:
-  case intValue:
-  case uintValue:
-  case realValue:
-  case booleanValue:
-    break;
-  case stringValue:
-    if (isAllocated())
-      releasePrefixedStringValue(value_.string_);
-    break;
-  case arrayValue:
-  case objectValue:
-    delete value_.map_;
-    break;
-  default:
-    JSON_ASSERT_UNREACHABLE;
-  }
-}
-
-void Value::dupMeta(const Value& other) {
-  comments_ = other.comments_;
-  start_ = other.start_;
-  limit_ = other.limit_;
-}
-
-// Access an object value by name, create a null member if it does not exist.
-// @pre Type of '*this' is object or null.
-// @param key is null-terminated.
-Value& Value::resolveReference(const char* key) {
-  JSON_ASSERT_MESSAGE(
-      type() == nullValue || type() == objectValue,
-      "in Json::Value::resolveReference(): requires objectValue");
-  if (type() == nullValue)
-    *this = Value(objectValue);
-  CZString actualKey(key, static_cast<unsigned>(strlen(key)),
-                     CZString::noDuplication); // NOTE!
-  auto it = value_.map_->lower_bound(actualKey);
-  if (it != value_.map_->end() && (*it).first == actualKey)
-    return (*it).second;
-
-  ObjectValues::value_type defaultValue(actualKey, nullSingleton());
-  it = value_.map_->insert(it, defaultValue);
-  Value& value = (*it).second;
-  return value;
-}
-
-// @param key is not null-terminated.
-Value& Value::resolveReference(char const* key, char const* end) {
-  JSON_ASSERT_MESSAGE(
-      type() == nullValue || type() == objectValue,
-      "in Json::Value::resolveReference(key, end): requires objectValue");
-  if (type() == nullValue)
-    *this = Value(objectValue);
-  CZString actualKey(key, static_cast<unsigned>(end - key),
-                     CZString::duplicateOnCopy);
-  auto it = value_.map_->lower_bound(actualKey);
-  if (it != value_.map_->end() && (*it).first == actualKey)
-    return (*it).second;
-
-  ObjectValues::value_type defaultValue(actualKey, nullSingleton());
-  it = value_.map_->insert(it, defaultValue);
-  Value& value = (*it).second;
-  return value;
-}
-
-Value Value::get(ArrayIndex index, const Value& defaultValue) const {
-  const Value* value = &((*this)[index]);
-  return value == &nullSingleton() ? defaultValue : *value;
-}
-
-bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
-
-Value const* Value::find(char const* begin, char const* end) const {
-  JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
-                      "in Json::Value::find(begin, end): requires "
-                      "objectValue or nullValue");
-  if (type() == nullValue)
-    return nullptr;
-  CZString actualKey(begin, static_cast<unsigned>(end - begin),
-                     CZString::noDuplication);
-  ObjectValues::const_iterator it = value_.map_->find(actualKey);
-  if (it == value_.map_->end())
-    return nullptr;
-  return &(*it).second;
-}
-Value* Value::demand(char const* begin, char const* end) {
-  JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
-                      "in Json::Value::demand(begin, end): requires "
-                      "objectValue or nullValue");
-  return &resolveReference(begin, end);
-}
-const Value& Value::operator[](const char* key) const {
-  Value const* found = find(key, key + strlen(key));
-  if (!found)
-    return nullSingleton();
-  return *found;
-}
-Value const& Value::operator[](const String& key) const {
-  Value const* found = find(key.data(), key.data() + key.length());
-  if (!found)
-    return nullSingleton();
-  return *found;
-}
-
-Value& Value::operator[](const char* key) {
-  return resolveReference(key, key + strlen(key));
-}
-
-Value& Value::operator[](const String& key) {
-  return resolveReference(key.data(), key.data() + key.length());
-}
-
-Value& Value::operator[](const StaticString& key) {
-  return resolveReference(key.c_str());
-}
-
-Value& Value::append(const Value& value) { return append(Value(value)); }
-
-Value& Value::append(Value&& value) {
-  JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
-                      "in Json::Value::append: requires arrayValue");
-  if (type() == nullValue) {
-    *this = Value(arrayValue);
-  }
-  return this->value_.map_->emplace(size(), std::move(value)).first->second;
-}
-
-bool Value::insert(ArrayIndex index, const Value& newValue) {
-  return insert(index, Value(newValue));
-}
-
-bool Value::insert(ArrayIndex index, Value&& newValue) {
-  JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue,
-                      "in Json::Value::insert: requires arrayValue");
-  ArrayIndex length = size();
-  if (index > length) {
-    return false;
-  }
-  for (ArrayIndex i = length; i > index; i--) {
-    (*this)[i] = std::move((*this)[i - 1]);
-  }
-  (*this)[index] = std::move(newValue);
-  return true;
-}
-
-Value Value::get(char const* begin, char const* end,
-                 Value const& defaultValue) const {
-  Value const* found = find(begin, end);
-  return !found ? defaultValue : *found;
-}
-Value Value::get(char const* key, Value const& defaultValue) const {
-  return get(key, key + strlen(key), defaultValue);
-}
-Value Value::get(String const& key, Value const& defaultValue) const {
-  return get(key.data(), key.data() + key.length(), defaultValue);
-}
-
-bool Value::removeMember(const char* begin, const char* end, Value* removed) {
-  if (type() != objectValue) {
-    return false;
-  }
-  CZString actualKey(begin, static_cast<unsigned>(end - begin),
-                     CZString::noDuplication);
-  auto it = value_.map_->find(actualKey);
-  if (it == value_.map_->end())
-    return false;
-  if (removed)
-    *removed = std::move(it->second);
-  value_.map_->erase(it);
-  return true;
-}
-bool Value::removeMember(const char* key, Value* removed) {
-  return removeMember(key, key + strlen(key), removed);
-}
-bool Value::removeMember(String const& key, Value* removed) {
-  return removeMember(key.data(), key.data() + key.length(), removed);
-}
-void Value::removeMember(const char* key) {
-  JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
-                      "in Json::Value::removeMember(): requires objectValue");
-  if (type() == nullValue)
-    return;
-
-  CZString actualKey(key, unsigned(strlen(key)), CZString::noDuplication);
-  value_.map_->erase(actualKey);
-}
-void Value::removeMember(const String& key) { removeMember(key.c_str()); }
-
-bool Value::removeIndex(ArrayIndex index, Value* removed) {
-  if (type() != arrayValue) {
-    return false;
-  }
-  CZString key(index);
-  auto it = value_.map_->find(key);
-  if (it == value_.map_->end()) {
-    return false;
-  }
-  if (removed)
-    *removed = it->second;
-  ArrayIndex oldSize = size();
-  // shift left all items left, into the place of the "removed"
-  for (ArrayIndex i = index; i < (oldSize - 1); ++i) {
-    CZString keey(i);
-    (*value_.map_)[keey] = (*this)[i + 1];
-  }
-  // erase the last one ("leftover")
-  CZString keyLast(oldSize - 1);
-  auto itLast = value_.map_->find(keyLast);
-  value_.map_->erase(itLast);
-  return true;
-}
-
-bool Value::isMember(char const* begin, char const* end) const {
-  Value const* value = find(begin, end);
-  return nullptr != value;
-}
-bool Value::isMember(char const* key) const {
-  return isMember(key, key + strlen(key));
-}
-bool Value::isMember(String const& key) const {
-  return isMember(key.data(), key.data() + key.length());
-}
-
-Value::Members Value::getMemberNames() const {
-  JSON_ASSERT_MESSAGE(
-      type() == nullValue || type() == objectValue,
-      "in Json::Value::getMemberNames(), value must be objectValue");
-  if (type() == nullValue)
-    return Value::Members();
-  Members members;
-  members.reserve(value_.map_->size());
-  ObjectValues::const_iterator it = value_.map_->begin();
-  ObjectValues::const_iterator itEnd = value_.map_->end();
-  for (; it != itEnd; ++it) {
-    members.push_back(String((*it).first.data(), (*it).first.length()));
-  }
-  return members;
-}
-
-static bool IsIntegral(double d) {
-  double integral_part;
-  return modf(d, &integral_part) == 0.0;
-}
-
-bool Value::isNull() const { return type() == nullValue; }
-
-bool Value::isBool() const { return type() == booleanValue; }
-
-bool Value::isInt() const {
-  switch (type()) {
-  case intValue:
-#if defined(JSON_HAS_INT64)
-    return value_.int_ >= minInt && value_.int_ <= maxInt;
-#else
-    return true;
-#endif
-  case uintValue:
-    return value_.uint_ <= UInt(maxInt);
-  case realValue:
-    return value_.real_ >= minInt && value_.real_ <= maxInt &&
-           IsIntegral(value_.real_);
-  default:
-    break;
-  }
-  return false;
-}
-
-bool Value::isUInt() const {
-  switch (type()) {
-  case intValue:
-#if defined(JSON_HAS_INT64)
-    return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
-#else
-    return value_.int_ >= 0;
-#endif
-  case uintValue:
-#if defined(JSON_HAS_INT64)
-    return value_.uint_ <= maxUInt;
-#else
-    return true;
-#endif
-  case realValue:
-    return value_.real_ >= 0 && value_.real_ <= maxUInt &&
-           IsIntegral(value_.real_);
-  default:
-    break;
-  }
-  return false;
-}
-
-bool Value::isInt64() const {
-#if defined(JSON_HAS_INT64)
-  switch (type()) {
-  case intValue:
-    return true;
-  case uintValue:
-    return value_.uint_ <= UInt64(maxInt64);
-  case realValue:
-    // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
-    // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
-    // require the value to be strictly less than the limit.
-    return value_.real_ >= double(minInt64) &&
-           value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
-  default:
-    break;
-  }
-#endif // JSON_HAS_INT64
-  return false;
-}
-
-bool Value::isUInt64() const {
-#if defined(JSON_HAS_INT64)
-  switch (type()) {
-  case intValue:
-    return value_.int_ >= 0;
-  case uintValue:
-    return true;
-  case realValue:
-    // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
-    // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
-    // require the value to be strictly less than the limit.
-    return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
-           IsIntegral(value_.real_);
-  default:
-    break;
-  }
-#endif // JSON_HAS_INT64
-  return false;
-}
-
-bool Value::isIntegral() const {
-  switch (type()) {
-  case intValue:
-  case uintValue:
-    return true;
-  case realValue:
-#if defined(JSON_HAS_INT64)
-    // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
-    // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
-    // require the value to be strictly less than the limit.
-    return value_.real_ >= double(minInt64) &&
-           value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
-#else
-    return value_.real_ >= minInt && value_.real_ <= maxUInt &&
-           IsIntegral(value_.real_);
-#endif // JSON_HAS_INT64
-  default:
-    break;
-  }
-  return false;
-}
-
-bool Value::isDouble() const {
-  return type() == intValue || type() == uintValue || type() == realValue;
-}
-
-bool Value::isNumeric() const { return isDouble(); }
-
-bool Value::isString() const { return type() == stringValue; }
-
-bool Value::isArray() const { return type() == arrayValue; }
-
-bool Value::isObject() const { return type() == objectValue; }
-
-Value::Comments::Comments(const Comments& that)
-    : ptr_{cloneUnique(that.ptr_)} {}
-
-Value::Comments::Comments(Comments&& that) noexcept
-    : ptr_{std::move(that.ptr_)} {}
-
-Value::Comments& Value::Comments::operator=(const Comments& that) {
-  ptr_ = cloneUnique(that.ptr_);
-  return *this;
-}
-
-Value::Comments& Value::Comments::operator=(Comments&& that) noexcept {
-  ptr_ = std::move(that.ptr_);
-  return *this;
-}
-
-bool Value::Comments::has(CommentPlacement slot) const {
-  return ptr_ && !(*ptr_)[slot].empty();
-}
-
-String Value::Comments::get(CommentPlacement slot) const {
-  if (!ptr_)
-    return {};
-  return (*ptr_)[slot];
-}
-
-void Value::Comments::set(CommentPlacement slot, String comment) {
-  if (slot >= CommentPlacement::numberOfCommentPlacement)
-    return;
-  if (!ptr_)
-    ptr_ = std::unique_ptr<Array>(new Array());
-  (*ptr_)[slot] = std::move(comment);
-}
-
-void Value::setComment(String comment, CommentPlacement placement) {
-  if (!comment.empty() && (comment.back() == '\n')) {
-    // Always discard trailing newline, to aid indentation.
-    comment.pop_back();
-  }
-  JSON_ASSERT(!comment.empty());
-  JSON_ASSERT_MESSAGE(
-      comment[0] == '\0' || comment[0] == '/',
-      "in Json::Value::setComment(): Comments must start with /");
-  comments_.set(placement, std::move(comment));
-}
-
-bool Value::hasComment(CommentPlacement placement) const {
-  return comments_.has(placement);
-}
-
-String Value::getComment(CommentPlacement placement) const {
-  return comments_.get(placement);
-}
-
-void Value::setOffsetStart(ptrdiff_t start) { start_ = start; }
-
-void Value::setOffsetLimit(ptrdiff_t limit) { limit_ = limit; }
-
-ptrdiff_t Value::getOffsetStart() const { return start_; }
-
-ptrdiff_t Value::getOffsetLimit() const { return limit_; }
-
-String Value::toStyledString() const {
-  StreamWriterBuilder builder;
-
-  String out = this->hasComment(commentBefore) ? "\n" : "";
-  out += Json::writeString(builder, *this);
-  out += '\n';
-
-  return out;
-}
-
-Value::const_iterator Value::begin() const {
-  switch (type()) {
-  case arrayValue:
-  case objectValue:
-    if (value_.map_)
-      return const_iterator(value_.map_->begin());
-    break;
-  default:
-    break;
-  }
-  return {};
-}
-
-Value::const_iterator Value::end() const {
-  switch (type()) {
-  case arrayValue:
-  case objectValue:
-    if (value_.map_)
-      return const_iterator(value_.map_->end());
-    break;
-  default:
-    break;
-  }
-  return {};
-}
-
-Value::iterator Value::begin() {
-  switch (type()) {
-  case arrayValue:
-  case objectValue:
-    if (value_.map_)
-      return iterator(value_.map_->begin());
-    break;
-  default:
-    break;
-  }
-  return iterator();
-}
-
-Value::iterator Value::end() {
-  switch (type()) {
-  case arrayValue:
-  case objectValue:
-    if (value_.map_)
-      return iterator(value_.map_->end());
-    break;
-  default:
-    break;
-  }
-  return iterator();
-}
-
-// class PathArgument
-// //////////////////////////////////////////////////////////////////
-
-PathArgument::PathArgument() = default;
-
-PathArgument::PathArgument(ArrayIndex index)
-    : index_(index), kind_(kindIndex) {}
-
-PathArgument::PathArgument(const char* key) : key_(key), kind_(kindKey) {}
-
-PathArgument::PathArgument(String key) : key_(std::move(key)), kind_(kindKey) {}
-
-// class Path
-// //////////////////////////////////////////////////////////////////
-
-Path::Path(const String& path, const PathArgument& a1, const PathArgument& a2,
-           const PathArgument& a3, const PathArgument& a4,
-           const PathArgument& a5) {
-  InArgs in;
-  in.reserve(5);
-  in.push_back(&a1);
-  in.push_back(&a2);
-  in.push_back(&a3);
-  in.push_back(&a4);
-  in.push_back(&a5);
-  makePath(path, in);
-}
-
-void Path::makePath(const String& path, const InArgs& in) {
-  const char* current = path.c_str();
-  const char* end = current + path.length();
-  auto itInArg = in.begin();
-  while (current != end) {
-    if (*current == '[') {
-      ++current;
-      if (*current == '%')
-        addPathInArg(path, in, itInArg, PathArgument::kindIndex);
-      else {
-        ArrayIndex index = 0;
-        for (; current != end && *current >= '0' && *current <= '9'; ++current)
-          index = index * 10 + ArrayIndex(*current - '0');
-        args_.push_back(index);
-      }
-      if (current == end || *++current != ']')
-        invalidPath(path, int(current - path.c_str()));
-    } else if (*current == '%') {
-      addPathInArg(path, in, itInArg, PathArgument::kindKey);
-      ++current;
-    } else if (*current == '.' || *current == ']') {
-      ++current;
-    } else {
-      const char* beginName = current;
-      while (current != end && !strchr("[.", *current))
-        ++current;
-      args_.push_back(String(beginName, current));
-    }
-  }
-}
-
-void Path::addPathInArg(const String& /*path*/, const InArgs& in,
-                        InArgs::const_iterator& itInArg,
-                        PathArgument::Kind kind) {
-  if (itInArg == in.end()) {
-    // Error: missing argument %d
-  } else if ((*itInArg)->kind_ != kind) {
-    // Error: bad argument type
-  } else {
-    args_.push_back(**itInArg++);
-  }
-}
-
-void Path::invalidPath(const String& /*path*/, int /*location*/) {
-  // Error: invalid path.
-}
-
-const Value& Path::resolve(const Value& root) const {
-  const Value* node = &root;
-  for (const auto& arg : args_) {
-    if (arg.kind_ == PathArgument::kindIndex) {
-      if (!node->isArray() || !node->isValidIndex(arg.index_)) {
-        // Error: unable to resolve path (array value expected at position... )
-        return Value::nullSingleton();
-      }
-      node = &((*node)[arg.index_]);
-    } else if (arg.kind_ == PathArgument::kindKey) {
-      if (!node->isObject()) {
-        // Error: unable to resolve path (object value expected at position...)
-        return Value::nullSingleton();
-      }
-      node = &((*node)[arg.key_]);
-      if (node == &Value::nullSingleton()) {
-        // Error: unable to resolve path (object has no member named '' at
-        // position...)
-        return Value::nullSingleton();
-      }
-    }
-  }
-  return *node;
-}
-
-Value Path::resolve(const Value& root, const Value& defaultValue) const {
-  const Value* node = &root;
-  for (const auto& arg : args_) {
-    if (arg.kind_ == PathArgument::kindIndex) {
-      if (!node->isArray() || !node->isValidIndex(arg.index_))
-        return defaultValue;
-      node = &((*node)[arg.index_]);
-    } else if (arg.kind_ == PathArgument::kindKey) {
-      if (!node->isObject())
-        return defaultValue;
-      node = &((*node)[arg.key_]);
-      if (node == &Value::nullSingleton())
-        return defaultValue;
-    }
-  }
-  return *node;
-}
-
-Value& Path::make(Value& root) const {
-  Value* node = &root;
-  for (const auto& arg : args_) {
-    if (arg.kind_ == PathArgument::kindIndex) {
-      if (!node->isArray()) {
-        // Error: node is not an array at position ...
-      }
-      node = &((*node)[arg.index_]);
-    } else if (arg.kind_ == PathArgument::kindKey) {
-      if (!node->isObject()) {
-        // Error: node is not an object at position...
-      }
-      node = &((*node)[arg.key_]);
-    }
-  }
-  return *node;
-}
-
-} // namespace Json
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: src/lib_json/json_value.cpp
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: src/lib_json/json_writer.cpp
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "json_tool.h"
-#include <json/writer.h>
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <algorithm>
-#include <cassert>
-#include <cctype>
-#include <cstring>
-#include <iomanip>
-#include <memory>
-#include <set>
-#include <sstream>
-#include <utility>
-
-#if __cplusplus >= 201103L
-#include <cmath>
-#include <cstdio>
-
-#if !defined(isnan)
-#define isnan std::isnan
-#endif
-
-#if !defined(isfinite)
-#define isfinite std::isfinite
-#endif
-
-#else
-#include <cmath>
-#include <cstdio>
-
-#if defined(_MSC_VER)
-#if !defined(isnan)
-#include <float.h>
-#define isnan _isnan
-#endif
-
-#if !defined(isfinite)
-#include <float.h>
-#define isfinite _finite
-#endif
-
-#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
-#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
-#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
-
-#endif //_MSC_VER
-
-#if defined(__sun) && defined(__SVR4) // Solaris
-#if !defined(isfinite)
-#include <ieeefp.h>
-#define isfinite finite
-#endif
-#endif
-
-#if defined(__hpux)
-#if !defined(isfinite)
-#if defined(__ia64) && !defined(finite)
-#define isfinite(x)                                                            \
-  ((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _IsFinite(x)))
-#endif
-#endif
-#endif
-
-#if !defined(isnan)
-// IEEE standard states that NaN values will not compare to themselves
-#define isnan(x) ((x) != (x))
-#endif
-
-#if !defined(__APPLE__)
-#if !defined(isfinite)
-#define isfinite finite
-#endif
-#endif
-#endif
-
-#if defined(_MSC_VER)
-// Disable warning about strdup being deprecated.
-#pragma warning(disable : 4996)
-#endif
-
-namespace Json {
-
-#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
-using StreamWriterPtr = std::unique_ptr<StreamWriter>;
-#else
-using StreamWriterPtr = std::auto_ptr<StreamWriter>;
-#endif
-
-String valueToString(LargestInt value) {
-  UIntToStringBuffer buffer;
-  char* current = buffer + sizeof(buffer);
-  if (value == Value::minLargestInt) {
-    uintToString(LargestUInt(Value::maxLargestInt) + 1, current);
-    *--current = '-';
-  } else if (value < 0) {
-    uintToString(LargestUInt(-value), current);
-    *--current = '-';
-  } else {
-    uintToString(LargestUInt(value), current);
-  }
-  assert(current >= buffer);
-  return current;
-}
-
-String valueToString(LargestUInt value) {
-  UIntToStringBuffer buffer;
-  char* current = buffer + sizeof(buffer);
-  uintToString(value, current);
-  assert(current >= buffer);
-  return current;
-}
-
-#if defined(JSON_HAS_INT64)
-
-String valueToString(Int value) { return valueToString(LargestInt(value)); }
-
-String valueToString(UInt value) { return valueToString(LargestUInt(value)); }
-
-#endif // # if defined(JSON_HAS_INT64)
-
-namespace {
-String valueToString(double value, bool useSpecialFloats,
-                     unsigned int precision, PrecisionType precisionType) {
-  // Print into the buffer. We need not request the alternative representation
-  // that always has a decimal point because JSON doesn't distinguish the
-  // concepts of reals and integers.
-  if (!isfinite(value)) {
-    static const char* const reps[2][3] = {{"NaN", "-Infinity", "Infinity"},
-                                           {"null", "-1e+9999", "1e+9999"}};
-    return reps[useSpecialFloats ? 0 : 1]
-               [isnan(value) ? 0 : (value < 0) ? 1 : 2];
-  }
-
-  String buffer(size_t(36), '\0');
-  while (true) {
-    int len = jsoncpp_snprintf(
-        &*buffer.begin(), buffer.size(),
-        (precisionType == PrecisionType::significantDigits) ? "%.*g" : "%.*f",
-        precision, value);
-    assert(len >= 0);
-    auto wouldPrint = static_cast<size_t>(len);
-    if (wouldPrint >= buffer.size()) {
-      buffer.resize(wouldPrint + 1);
-      continue;
-    }
-    buffer.resize(wouldPrint);
-    break;
-  }
-
-  buffer.erase(fixNumericLocale(buffer.begin(), buffer.end()), buffer.end());
-
-  // try to ensure we preserve the fact that this was given to us as a double on
-  // input
-  if (buffer.find('.') == buffer.npos && buffer.find('e') == buffer.npos) {
-    buffer += ".0";
-  }
-
-  // strip the zero padding from the right
-  if (precisionType == PrecisionType::decimalPlaces) {
-    buffer.erase(fixZerosInTheEnd(buffer.begin(), buffer.end(), precision),
-                 buffer.end());
-  }
-
-  return buffer;
-}
-} // namespace
-
-String valueToString(double value, unsigned int precision,
-                     PrecisionType precisionType) {
-  return valueToString(value, false, precision, precisionType);
-}
-
-String valueToString(bool value) { return value ? "true" : "false"; }
-
-static bool doesAnyCharRequireEscaping(char const* s, size_t n) {
-  assert(s || !n);
-
-  return std::any_of(s, s + n, [](unsigned char c) {
-    return c == '\\' || c == '"' || c < 0x20 || c > 0x7F;
-  });
-}
-
-static unsigned int utf8ToCodepoint(const char*& s, const char* e) {
-  const unsigned int REPLACEMENT_CHARACTER = 0xFFFD;
-
-  unsigned int firstByte = static_cast<unsigned char>(*s);
-
-  if (firstByte < 0x80)
-    return firstByte;
-
-  if (firstByte < 0xE0) {
-    if (e - s < 2)
-      return REPLACEMENT_CHARACTER;
-
-    unsigned int calculated =
-        ((firstByte & 0x1F) << 6) | (static_cast<unsigned int>(s[1]) & 0x3F);
-    s += 1;
-    // oversized encoded characters are invalid
-    return calculated < 0x80 ? REPLACEMENT_CHARACTER : calculated;
-  }
-
-  if (firstByte < 0xF0) {
-    if (e - s < 3)
-      return REPLACEMENT_CHARACTER;
-
-    unsigned int calculated = ((firstByte & 0x0F) << 12) |
-                              ((static_cast<unsigned int>(s[1]) & 0x3F) << 6) |
-                              (static_cast<unsigned int>(s[2]) & 0x3F);
-    s += 2;
-    // surrogates aren't valid codepoints itself
-    // shouldn't be UTF-8 encoded
-    if (calculated >= 0xD800 && calculated <= 0xDFFF)
-      return REPLACEMENT_CHARACTER;
-    // oversized encoded characters are invalid
-    return calculated < 0x800 ? REPLACEMENT_CHARACTER : calculated;
-  }
-
-  if (firstByte < 0xF8) {
-    if (e - s < 4)
-      return REPLACEMENT_CHARACTER;
-
-    unsigned int calculated = ((firstByte & 0x07) << 18) |
-                              ((static_cast<unsigned int>(s[1]) & 0x3F) << 12) |
-                              ((static_cast<unsigned int>(s[2]) & 0x3F) << 6) |
-                              (static_cast<unsigned int>(s[3]) & 0x3F);
-    s += 3;
-    // oversized encoded characters are invalid
-    return calculated < 0x10000 ? REPLACEMENT_CHARACTER : calculated;
-  }
-
-  return REPLACEMENT_CHARACTER;
-}
-
-static const char hex2[] = "000102030405060708090a0b0c0d0e0f"
-                           "101112131415161718191a1b1c1d1e1f"
-                           "202122232425262728292a2b2c2d2e2f"
-                           "303132333435363738393a3b3c3d3e3f"
-                           "404142434445464748494a4b4c4d4e4f"
-                           "505152535455565758595a5b5c5d5e5f"
-                           "606162636465666768696a6b6c6d6e6f"
-                           "707172737475767778797a7b7c7d7e7f"
-                           "808182838485868788898a8b8c8d8e8f"
-                           "909192939495969798999a9b9c9d9e9f"
-                           "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
-                           "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
-                           "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
-                           "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
-                           "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
-                           "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
-
-static String toHex16Bit(unsigned int x) {
-  const unsigned int hi = (x >> 8) & 0xff;
-  const unsigned int lo = x & 0xff;
-  String result(4, ' ');
-  result[0] = hex2[2 * hi];
-  result[1] = hex2[2 * hi + 1];
-  result[2] = hex2[2 * lo];
-  result[3] = hex2[2 * lo + 1];
-  return result;
-}
-
-static void appendRaw(String& result, unsigned ch) {
-  result += static_cast<char>(ch);
-}
-
-static void appendHex(String& result, unsigned ch) {
-  result.append("\\u").append(toHex16Bit(ch));
-}
-
-static String valueToQuotedStringN(const char* value, size_t length,
-                                   bool emitUTF8 = false) {
-  if (value == nullptr)
-    return "";
-
-  if (!doesAnyCharRequireEscaping(value, length))
-    return String("\"") + value + "\"";
-  // We have to walk value and escape any special characters.
-  // Appending to String is not efficient, but this should be rare.
-  // (Note: forward slashes are *not* rare, but I am not escaping them.)
-  String::size_type maxsize = length * 2 + 3; // allescaped+quotes+NULL
-  String result;
-  result.reserve(maxsize); // to avoid lots of mallocs
-  result += "\"";
-  char const* end = value + length;
-  for (const char* c = value; c != end; ++c) {
-    switch (*c) {
-    case '\"':
-      result += "\\\"";
-      break;
-    case '\\':
-      result += "\\\\";
-      break;
-    case '\b':
-      result += "\\b";
-      break;
-    case '\f':
-      result += "\\f";
-      break;
-    case '\n':
-      result += "\\n";
-      break;
-    case '\r':
-      result += "\\r";
-      break;
-    case '\t':
-      result += "\\t";
-      break;
-    // case '/':
-    // Even though \/ is considered a legal escape in JSON, a bare
-    // slash is also legal, so I see no reason to escape it.
-    // (I hope I am not misunderstanding something.)
-    // blep notes: actually escaping \/ may be useful in javascript to avoid </
-    // sequence.
-    // Should add a flag to allow this compatibility mode and prevent this
-    // sequence from occurring.
-    default: {
-      if (emitUTF8) {
-        unsigned codepoint = static_cast<unsigned char>(*c);
-        if (codepoint < 0x20) {
-          appendHex(result, codepoint);
-        } else {
-          appendRaw(result, codepoint);
-        }
-      } else {
-        unsigned codepoint = utf8ToCodepoint(c, end); // modifies `c`
-        if (codepoint < 0x20) {
-          appendHex(result, codepoint);
-        } else if (codepoint < 0x80) {
-          appendRaw(result, codepoint);
-        } else if (codepoint < 0x10000) {
-          // Basic Multilingual Plane
-          appendHex(result, codepoint);
-        } else {
-          // Extended Unicode. Encode 20 bits as a surrogate pair.
-          codepoint -= 0x10000;
-          appendHex(result, 0xd800 + ((codepoint >> 10) & 0x3ff));
-          appendHex(result, 0xdc00 + (codepoint & 0x3ff));
-        }
-      }
-    } break;
-    }
-  }
-  result += "\"";
-  return result;
-}
-
-String valueToQuotedString(const char* value) {
-  return valueToQuotedStringN(value, strlen(value));
-}
-
-// Class Writer
-// //////////////////////////////////////////////////////////////////
-Writer::~Writer() = default;
-
-// Class FastWriter
-// //////////////////////////////////////////////////////////////////
-
-FastWriter::FastWriter()
-
-    = default;
-
-void FastWriter::enableYAMLCompatibility() { yamlCompatibilityEnabled_ = true; }
-
-void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
-
-void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
-
-String FastWriter::write(const Value& root) {
-  document_.clear();
-  writeValue(root);
-  if (!omitEndingLineFeed_)
-    document_ += '\n';
-  return document_;
-}
-
-void FastWriter::writeValue(const Value& value) {
-  switch (value.type()) {
-  case nullValue:
-    if (!dropNullPlaceholders_)
-      document_ += "null";
-    break;
-  case intValue:
-    document_ += valueToString(value.asLargestInt());
-    break;
-  case uintValue:
-    document_ += valueToString(value.asLargestUInt());
-    break;
-  case realValue:
-    document_ += valueToString(value.asDouble());
-    break;
-  case stringValue: {
-    // Is NULL possible for value.string_? No.
-    char const* str;
-    char const* end;
-    bool ok = value.getString(&str, &end);
-    if (ok)
-      document_ += valueToQuotedStringN(str, static_cast<size_t>(end - str));
-    break;
-  }
-  case booleanValue:
-    document_ += valueToString(value.asBool());
-    break;
-  case arrayValue: {
-    document_ += '[';
-    ArrayIndex size = value.size();
-    for (ArrayIndex index = 0; index < size; ++index) {
-      if (index > 0)
-        document_ += ',';
-      writeValue(value[index]);
-    }
-    document_ += ']';
-  } break;
-  case objectValue: {
-    Value::Members members(value.getMemberNames());
-    document_ += '{';
-    for (auto it = members.begin(); it != members.end(); ++it) {
-      const String& name = *it;
-      if (it != members.begin())
-        document_ += ',';
-      document_ += valueToQuotedStringN(name.data(), name.length());
-      document_ += yamlCompatibilityEnabled_ ? ": " : ":";
-      writeValue(value[name]);
-    }
-    document_ += '}';
-  } break;
-  }
-}
-
-// Class StyledWriter
-// //////////////////////////////////////////////////////////////////
-
-StyledWriter::StyledWriter() = default;
-
-String StyledWriter::write(const Value& root) {
-  document_.clear();
-  addChildValues_ = false;
-  indentString_.clear();
-  writeCommentBeforeValue(root);
-  writeValue(root);
-  writeCommentAfterValueOnSameLine(root);
-  document_ += '\n';
-  return document_;
-}
-
-void StyledWriter::writeValue(const Value& value) {
-  switch (value.type()) {
-  case nullValue:
-    pushValue("null");
-    break;
-  case intValue:
-    pushValue(valueToString(value.asLargestInt()));
-    break;
-  case uintValue:
-    pushValue(valueToString(value.asLargestUInt()));
-    break;
-  case realValue:
-    pushValue(valueToString(value.asDouble()));
-    break;
-  case stringValue: {
-    // Is NULL possible for value.string_? No.
-    char const* str;
-    char const* end;
-    bool ok = value.getString(&str, &end);
-    if (ok)
-      pushValue(valueToQuotedStringN(str, static_cast<size_t>(end - str)));
-    else
-      pushValue("");
-    break;
-  }
-  case booleanValue:
-    pushValue(valueToString(value.asBool()));
-    break;
-  case arrayValue:
-    writeArrayValue(value);
-    break;
-  case objectValue: {
-    Value::Members members(value.getMemberNames());
-    if (members.empty())
-      pushValue("{}");
-    else {
-      writeWithIndent("{");
-      indent();
-      auto it = members.begin();
-      for (;;) {
-        const String& name = *it;
-        const Value& childValue = value[name];
-        writeCommentBeforeValue(childValue);
-        writeWithIndent(valueToQuotedString(name.c_str()));
-        document_ += " : ";
-        writeValue(childValue);
-        if (++it == members.end()) {
-          writeCommentAfterValueOnSameLine(childValue);
-          break;
-        }
-        document_ += ',';
-        writeCommentAfterValueOnSameLine(childValue);
-      }
-      unindent();
-      writeWithIndent("}");
-    }
-  } break;
-  }
-}
-
-void StyledWriter::writeArrayValue(const Value& value) {
-  size_t size = value.size();
-  if (size == 0)
-    pushValue("[]");
-  else {
-    bool isArrayMultiLine = isMultilineArray(value);
-    if (isArrayMultiLine) {
-      writeWithIndent("[");
-      indent();
-      bool hasChildValue = !childValues_.empty();
-      ArrayIndex index = 0;
-      for (;;) {
-        const Value& childValue = value[index];
-        writeCommentBeforeValue(childValue);
-        if (hasChildValue)
-          writeWithIndent(childValues_[index]);
-        else {
-          writeIndent();
-          writeValue(childValue);
-        }
-        if (++index == size) {
-          writeCommentAfterValueOnSameLine(childValue);
-          break;
-        }
-        document_ += ',';
-        writeCommentAfterValueOnSameLine(childValue);
-      }
-      unindent();
-      writeWithIndent("]");
-    } else // output on a single line
-    {
-      assert(childValues_.size() == size);
-      document_ += "[ ";
-      for (size_t index = 0; index < size; ++index) {
-        if (index > 0)
-          document_ += ", ";
-        document_ += childValues_[index];
-      }
-      document_ += " ]";
-    }
-  }
-}
-
-bool StyledWriter::isMultilineArray(const Value& value) {
-  ArrayIndex const size = value.size();
-  bool isMultiLine = size * 3 >= rightMargin_;
-  childValues_.clear();
-  for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
-    const Value& childValue = value[index];
-    isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
-                   !childValue.empty());
-  }
-  if (!isMultiLine) // check if line length > max line length
-  {
-    childValues_.reserve(size);
-    addChildValues_ = true;
-    ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
-    for (ArrayIndex index = 0; index < size; ++index) {
-      if (hasCommentForValue(value[index])) {
-        isMultiLine = true;
-      }
-      writeValue(value[index]);
-      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
-    }
-    addChildValues_ = false;
-    isMultiLine = isMultiLine || lineLength >= rightMargin_;
-  }
-  return isMultiLine;
-}
-
-void StyledWriter::pushValue(const String& value) {
-  if (addChildValues_)
-    childValues_.push_back(value);
-  else
-    document_ += value;
-}
-
-void StyledWriter::writeIndent() {
-  if (!document_.empty()) {
-    char last = document_[document_.length() - 1];
-    if (last == ' ') // already indented
-      return;
-    if (last != '\n') // Comments may add new-line
-      document_ += '\n';
-  }
-  document_ += indentString_;
-}
-
-void StyledWriter::writeWithIndent(const String& value) {
-  writeIndent();
-  document_ += value;
-}
-
-void StyledWriter::indent() { indentString_ += String(indentSize_, ' '); }
-
-void StyledWriter::unindent() {
-  assert(indentString_.size() >= indentSize_);
-  indentString_.resize(indentString_.size() - indentSize_);
-}
-
-void StyledWriter::writeCommentBeforeValue(const Value& root) {
-  if (!root.hasComment(commentBefore))
-    return;
-
-  document_ += '\n';
-  writeIndent();
-  const String& comment = root.getComment(commentBefore);
-  String::const_iterator iter = comment.begin();
-  while (iter != comment.end()) {
-    document_ += *iter;
-    if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
-      writeIndent();
-    ++iter;
-  }
-
-  // Comments are stripped of trailing newlines, so add one here
-  document_ += '\n';
-}
-
-void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
-  if (root.hasComment(commentAfterOnSameLine))
-    document_ += " " + root.getComment(commentAfterOnSameLine);
-
-  if (root.hasComment(commentAfter)) {
-    document_ += '\n';
-    document_ += root.getComment(commentAfter);
-    document_ += '\n';
-  }
-}
-
-bool StyledWriter::hasCommentForValue(const Value& value) {
-  return value.hasComment(commentBefore) ||
-         value.hasComment(commentAfterOnSameLine) ||
-         value.hasComment(commentAfter);
-}
-
-// Class StyledStreamWriter
-// //////////////////////////////////////////////////////////////////
-
-StyledStreamWriter::StyledStreamWriter(String indentation)
-    : document_(nullptr), indentation_(std::move(indentation)),
-      addChildValues_(), indented_(false) {}
-
-void StyledStreamWriter::write(OStream& out, const Value& root) {
-  document_ = &out;
-  addChildValues_ = false;
-  indentString_.clear();
-  indented_ = true;
-  writeCommentBeforeValue(root);
-  if (!indented_)
-    writeIndent();
-  indented_ = true;
-  writeValue(root);
-  writeCommentAfterValueOnSameLine(root);
-  *document_ << "\n";
-  document_ = nullptr; // Forget the stream, for safety.
-}
-
-void StyledStreamWriter::writeValue(const Value& value) {
-  switch (value.type()) {
-  case nullValue:
-    pushValue("null");
-    break;
-  case intValue:
-    pushValue(valueToString(value.asLargestInt()));
-    break;
-  case uintValue:
-    pushValue(valueToString(value.asLargestUInt()));
-    break;
-  case realValue:
-    pushValue(valueToString(value.asDouble()));
-    break;
-  case stringValue: {
-    // Is NULL possible for value.string_? No.
-    char const* str;
-    char const* end;
-    bool ok = value.getString(&str, &end);
-    if (ok)
-      pushValue(valueToQuotedStringN(str, static_cast<size_t>(end - str)));
-    else
-      pushValue("");
-    break;
-  }
-  case booleanValue:
-    pushValue(valueToString(value.asBool()));
-    break;
-  case arrayValue:
-    writeArrayValue(value);
-    break;
-  case objectValue: {
-    Value::Members members(value.getMemberNames());
-    if (members.empty())
-      pushValue("{}");
-    else {
-      writeWithIndent("{");
-      indent();
-      auto it = members.begin();
-      for (;;) {
-        const String& name = *it;
-        const Value& childValue = value[name];
-        writeCommentBeforeValue(childValue);
-        writeWithIndent(valueToQuotedString(name.c_str()));
-        *document_ << " : ";
-        writeValue(childValue);
-        if (++it == members.end()) {
-          writeCommentAfterValueOnSameLine(childValue);
-          break;
-        }
-        *document_ << ",";
-        writeCommentAfterValueOnSameLine(childValue);
-      }
-      unindent();
-      writeWithIndent("}");
-    }
-  } break;
-  }
-}
-
-void StyledStreamWriter::writeArrayValue(const Value& value) {
-  unsigned size = value.size();
-  if (size == 0)
-    pushValue("[]");
-  else {
-    bool isArrayMultiLine = isMultilineArray(value);
-    if (isArrayMultiLine) {
-      writeWithIndent("[");
-      indent();
-      bool hasChildValue = !childValues_.empty();
-      unsigned index = 0;
-      for (;;) {
-        const Value& childValue = value[index];
-        writeCommentBeforeValue(childValue);
-        if (hasChildValue)
-          writeWithIndent(childValues_[index]);
-        else {
-          if (!indented_)
-            writeIndent();
-          indented_ = true;
-          writeValue(childValue);
-          indented_ = false;
-        }
-        if (++index == size) {
-          writeCommentAfterValueOnSameLine(childValue);
-          break;
-        }
-        *document_ << ",";
-        writeCommentAfterValueOnSameLine(childValue);
-      }
-      unindent();
-      writeWithIndent("]");
-    } else // output on a single line
-    {
-      assert(childValues_.size() == size);
-      *document_ << "[ ";
-      for (unsigned index = 0; index < size; ++index) {
-        if (index > 0)
-          *document_ << ", ";
-        *document_ << childValues_[index];
-      }
-      *document_ << " ]";
-    }
-  }
-}
-
-bool StyledStreamWriter::isMultilineArray(const Value& value) {
-  ArrayIndex const size = value.size();
-  bool isMultiLine = size * 3 >= rightMargin_;
-  childValues_.clear();
-  for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
-    const Value& childValue = value[index];
-    isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
-                   !childValue.empty());
-  }
-  if (!isMultiLine) // check if line length > max line length
-  {
-    childValues_.reserve(size);
-    addChildValues_ = true;
-    ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
-    for (ArrayIndex index = 0; index < size; ++index) {
-      if (hasCommentForValue(value[index])) {
-        isMultiLine = true;
-      }
-      writeValue(value[index]);
-      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
-    }
-    addChildValues_ = false;
-    isMultiLine = isMultiLine || lineLength >= rightMargin_;
-  }
-  return isMultiLine;
-}
-
-void StyledStreamWriter::pushValue(const String& value) {
-  if (addChildValues_)
-    childValues_.push_back(value);
-  else
-    *document_ << value;
-}
-
-void StyledStreamWriter::writeIndent() {
-  // blep intended this to look at the so-far-written string
-  // to determine whether we are already indented, but
-  // with a stream we cannot do that. So we rely on some saved state.
-  // The caller checks indented_.
-  *document_ << '\n' << indentString_;
-}
-
-void StyledStreamWriter::writeWithIndent(const String& value) {
-  if (!indented_)
-    writeIndent();
-  *document_ << value;
-  indented_ = false;
-}
-
-void StyledStreamWriter::indent() { indentString_ += indentation_; }
-
-void StyledStreamWriter::unindent() {
-  assert(indentString_.size() >= indentation_.size());
-  indentString_.resize(indentString_.size() - indentation_.size());
-}
-
-void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
-  if (!root.hasComment(commentBefore))
-    return;
-
-  if (!indented_)
-    writeIndent();
-  const String& comment = root.getComment(commentBefore);
-  String::const_iterator iter = comment.begin();
-  while (iter != comment.end()) {
-    *document_ << *iter;
-    if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
-      // writeIndent();  // would include newline
-      *document_ << indentString_;
-    ++iter;
-  }
-  indented_ = false;
-}
-
-void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
-  if (root.hasComment(commentAfterOnSameLine))
-    *document_ << ' ' << root.getComment(commentAfterOnSameLine);
-
-  if (root.hasComment(commentAfter)) {
-    writeIndent();
-    *document_ << root.getComment(commentAfter);
-  }
-  indented_ = false;
-}
-
-bool StyledStreamWriter::hasCommentForValue(const Value& value) {
-  return value.hasComment(commentBefore) ||
-         value.hasComment(commentAfterOnSameLine) ||
-         value.hasComment(commentAfter);
-}
-
-//////////////////////////
-// BuiltStyledStreamWriter
-
-/// Scoped enums are not available until C++11.
-struct CommentStyle {
-  /// Decide whether to write comments.
-  enum Enum {
-    None, ///< Drop all comments.
-    Most, ///< Recover odd behavior of previous versions (not implemented yet).
-    All   ///< Keep all comments.
-  };
-};
-
-struct BuiltStyledStreamWriter : public StreamWriter {
-  BuiltStyledStreamWriter(String indentation, CommentStyle::Enum cs,
-                          String colonSymbol, String nullSymbol,
-                          String endingLineFeedSymbol, bool useSpecialFloats,
-                          bool emitUTF8, unsigned int precision,
-                          PrecisionType precisionType);
-  int write(Value const& root, OStream* sout) override;
-
-private:
-  void writeValue(Value const& value);
-  void writeArrayValue(Value const& value);
-  bool isMultilineArray(Value const& value);
-  void pushValue(String const& value);
-  void writeIndent();
-  void writeWithIndent(String const& value);
-  void indent();
-  void unindent();
-  void writeCommentBeforeValue(Value const& root);
-  void writeCommentAfterValueOnSameLine(Value const& root);
-  static bool hasCommentForValue(const Value& value);
-
-  using ChildValues = std::vector<String>;
-
-  ChildValues childValues_;
-  String indentString_;
-  unsigned int rightMargin_;
-  String indentation_;
-  CommentStyle::Enum cs_;
-  String colonSymbol_;
-  String nullSymbol_;
-  String endingLineFeedSymbol_;
-  bool addChildValues_ : 1;
-  bool indented_ : 1;
-  bool useSpecialFloats_ : 1;
-  bool emitUTF8_ : 1;
-  unsigned int precision_;
-  PrecisionType precisionType_;
-};
-BuiltStyledStreamWriter::BuiltStyledStreamWriter(
-    String indentation, CommentStyle::Enum cs, String colonSymbol,
-    String nullSymbol, String endingLineFeedSymbol, bool useSpecialFloats,
-    bool emitUTF8, unsigned int precision, PrecisionType precisionType)
-    : rightMargin_(74), indentation_(std::move(indentation)), cs_(cs),
-      colonSymbol_(std::move(colonSymbol)), nullSymbol_(std::move(nullSymbol)),
-      endingLineFeedSymbol_(std::move(endingLineFeedSymbol)),
-      addChildValues_(false), indented_(false),
-      useSpecialFloats_(useSpecialFloats), emitUTF8_(emitUTF8),
-      precision_(precision), precisionType_(precisionType) {}
-int BuiltStyledStreamWriter::write(Value const& root, OStream* sout) {
-  sout_ = sout;
-  addChildValues_ = false;
-  indented_ = true;
-  indentString_.clear();
-  writeCommentBeforeValue(root);
-  if (!indented_)
-    writeIndent();
-  indented_ = true;
-  writeValue(root);
-  writeCommentAfterValueOnSameLine(root);
-  *sout_ << endingLineFeedSymbol_;
-  sout_ = nullptr;
-  return 0;
-}
-void BuiltStyledStreamWriter::writeValue(Value const& value) {
-  switch (value.type()) {
-  case nullValue:
-    pushValue(nullSymbol_);
-    break;
-  case intValue:
-    pushValue(valueToString(value.asLargestInt()));
-    break;
-  case uintValue:
-    pushValue(valueToString(value.asLargestUInt()));
-    break;
-  case realValue:
-    pushValue(valueToString(value.asDouble(), useSpecialFloats_, precision_,
-                            precisionType_));
-    break;
-  case stringValue: {
-    // Is NULL is possible for value.string_? No.
-    char const* str;
-    char const* end;
-    bool ok = value.getString(&str, &end);
-    if (ok)
-      pushValue(
-          valueToQuotedStringN(str, static_cast<size_t>(end - str), emitUTF8_));
-    else
-      pushValue("");
-    break;
-  }
-  case booleanValue:
-    pushValue(valueToString(value.asBool()));
-    break;
-  case arrayValue:
-    writeArrayValue(value);
-    break;
-  case objectValue: {
-    Value::Members members(value.getMemberNames());
-    if (members.empty())
-      pushValue("{}");
-    else {
-      writeWithIndent("{");
-      indent();
-      auto it = members.begin();
-      for (;;) {
-        String const& name = *it;
-        Value const& childValue = value[name];
-        writeCommentBeforeValue(childValue);
-        writeWithIndent(
-            valueToQuotedStringN(name.data(), name.length(), emitUTF8_));
-        *sout_ << colonSymbol_;
-        writeValue(childValue);
-        if (++it == members.end()) {
-          writeCommentAfterValueOnSameLine(childValue);
-          break;
-        }
-        *sout_ << ",";
-        writeCommentAfterValueOnSameLine(childValue);
-      }
-      unindent();
-      writeWithIndent("}");
-    }
-  } break;
-  }
-}
-
-void BuiltStyledStreamWriter::writeArrayValue(Value const& value) {
-  unsigned size = value.size();
-  if (size == 0)
-    pushValue("[]");
-  else {
-    bool isMultiLine = (cs_ == CommentStyle::All) || isMultilineArray(value);
-    if (isMultiLine) {
-      writeWithIndent("[");
-      indent();
-      bool hasChildValue = !childValues_.empty();
-      unsigned index = 0;
-      for (;;) {
-        Value const& childValue = value[index];
-        writeCommentBeforeValue(childValue);
-        if (hasChildValue)
-          writeWithIndent(childValues_[index]);
-        else {
-          if (!indented_)
-            writeIndent();
-          indented_ = true;
-          writeValue(childValue);
-          indented_ = false;
-        }
-        if (++index == size) {
-          writeCommentAfterValueOnSameLine(childValue);
-          break;
-        }
-        *sout_ << ",";
-        writeCommentAfterValueOnSameLine(childValue);
-      }
-      unindent();
-      writeWithIndent("]");
-    } else // output on a single line
-    {
-      assert(childValues_.size() == size);
-      *sout_ << "[";
-      if (!indentation_.empty())
-        *sout_ << " ";
-      for (unsigned index = 0; index < size; ++index) {
-        if (index > 0)
-          *sout_ << ((!indentation_.empty()) ? ", " : ",");
-        *sout_ << childValues_[index];
-      }
-      if (!indentation_.empty())
-        *sout_ << " ";
-      *sout_ << "]";
-    }
-  }
-}
-
-bool BuiltStyledStreamWriter::isMultilineArray(Value const& value) {
-  ArrayIndex const size = value.size();
-  bool isMultiLine = size * 3 >= rightMargin_;
-  childValues_.clear();
-  for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
-    Value const& childValue = value[index];
-    isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
-                   !childValue.empty());
-  }
-  if (!isMultiLine) // check if line length > max line length
-  {
-    childValues_.reserve(size);
-    addChildValues_ = true;
-    ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
-    for (ArrayIndex index = 0; index < size; ++index) {
-      if (hasCommentForValue(value[index])) {
-        isMultiLine = true;
-      }
-      writeValue(value[index]);
-      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
-    }
-    addChildValues_ = false;
-    isMultiLine = isMultiLine || lineLength >= rightMargin_;
-  }
-  return isMultiLine;
-}
-
-void BuiltStyledStreamWriter::pushValue(String const& value) {
-  if (addChildValues_)
-    childValues_.push_back(value);
-  else
-    *sout_ << value;
-}
-
-void BuiltStyledStreamWriter::writeIndent() {
-  // blep intended this to look at the so-far-written string
-  // to determine whether we are already indented, but
-  // with a stream we cannot do that. So we rely on some saved state.
-  // The caller checks indented_.
-
-  if (!indentation_.empty()) {
-    // In this case, drop newlines too.
-    *sout_ << '\n' << indentString_;
-  }
-}
-
-void BuiltStyledStreamWriter::writeWithIndent(String const& value) {
-  if (!indented_)
-    writeIndent();
-  *sout_ << value;
-  indented_ = false;
-}
-
-void BuiltStyledStreamWriter::indent() { indentString_ += indentation_; }
-
-void BuiltStyledStreamWriter::unindent() {
-  assert(indentString_.size() >= indentation_.size());
-  indentString_.resize(indentString_.size() - indentation_.size());
-}
-
-void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
-  if (cs_ == CommentStyle::None)
-    return;
-  if (!root.hasComment(commentBefore))
-    return;
-
-  if (!indented_)
-    writeIndent();
-  const String& comment = root.getComment(commentBefore);
-  String::const_iterator iter = comment.begin();
-  while (iter != comment.end()) {
-    *sout_ << *iter;
-    if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
-      // writeIndent();  // would write extra newline
-      *sout_ << indentString_;
-    ++iter;
-  }
-  indented_ = false;
-}
-
-void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(
-    Value const& root) {
-  if (cs_ == CommentStyle::None)
-    return;
-  if (root.hasComment(commentAfterOnSameLine))
-    *sout_ << " " + root.getComment(commentAfterOnSameLine);
-
-  if (root.hasComment(commentAfter)) {
-    writeIndent();
-    *sout_ << root.getComment(commentAfter);
-  }
-}
-
-// static
-bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value) {
-  return value.hasComment(commentBefore) ||
-         value.hasComment(commentAfterOnSameLine) ||
-         value.hasComment(commentAfter);
-}
-
-///////////////
-// StreamWriter
-
-StreamWriter::StreamWriter() : sout_(nullptr) {}
-StreamWriter::~StreamWriter() = default;
-StreamWriter::Factory::~Factory() = default;
-StreamWriterBuilder::StreamWriterBuilder() { setDefaults(&settings_); }
-StreamWriterBuilder::~StreamWriterBuilder() = default;
-StreamWriter* StreamWriterBuilder::newStreamWriter() const {
-  const String indentation = settings_["indentation"].asString();
-  const String cs_str = settings_["commentStyle"].asString();
-  const String pt_str = settings_["precisionType"].asString();
-  const bool eyc = settings_["enableYAMLCompatibility"].asBool();
-  const bool dnp = settings_["dropNullPlaceholders"].asBool();
-  const bool usf = settings_["useSpecialFloats"].asBool();
-  const bool emitUTF8 = settings_["emitUTF8"].asBool();
-  unsigned int pre = settings_["precision"].asUInt();
-  CommentStyle::Enum cs = CommentStyle::All;
-  if (cs_str == "All") {
-    cs = CommentStyle::All;
-  } else if (cs_str == "None") {
-    cs = CommentStyle::None;
-  } else {
-    throwRuntimeError("commentStyle must be 'All' or 'None'");
-  }
-  PrecisionType precisionType(significantDigits);
-  if (pt_str == "significant") {
-    precisionType = PrecisionType::significantDigits;
-  } else if (pt_str == "decimal") {
-    precisionType = PrecisionType::decimalPlaces;
-  } else {
-    throwRuntimeError("precisionType must be 'significant' or 'decimal'");
-  }
-  String colonSymbol = " : ";
-  if (eyc) {
-    colonSymbol = ": ";
-  } else if (indentation.empty()) {
-    colonSymbol = ":";
-  }
-  String nullSymbol = "null";
-  if (dnp) {
-    nullSymbol.clear();
-  }
-  if (pre > 17)
-    pre = 17;
-  String endingLineFeedSymbol;
-  return new BuiltStyledStreamWriter(indentation, cs, colonSymbol, nullSymbol,
-                                     endingLineFeedSymbol, usf, emitUTF8, pre,
-                                     precisionType);
-}
-
-bool StreamWriterBuilder::validate(Json::Value* invalid) const {
-  static const auto& valid_keys = *new std::set<String>{
-      "indentation",
-      "commentStyle",
-      "enableYAMLCompatibility",
-      "dropNullPlaceholders",
-      "useSpecialFloats",
-      "emitUTF8",
-      "precision",
-      "precisionType",
-  };
-  for (auto si = settings_.begin(); si != settings_.end(); ++si) {
-    auto key = si.name();
-    if (valid_keys.count(key))
-      continue;
-    if (invalid)
-      (*invalid)[key] = *si;
-    else
-      return false;
-  }
-  return invalid ? invalid->empty() : true;
-}
-
-Value& StreamWriterBuilder::operator[](const String& key) {
-  return settings_[key];
-}
-// static
-void StreamWriterBuilder::setDefaults(Json::Value* settings) {
-  //! [StreamWriterBuilderDefaults]
-  (*settings)["commentStyle"] = "All";
-  (*settings)["indentation"] = "\t";
-  (*settings)["enableYAMLCompatibility"] = false;
-  (*settings)["dropNullPlaceholders"] = false;
-  (*settings)["useSpecialFloats"] = false;
-  (*settings)["emitUTF8"] = false;
-  (*settings)["precision"] = 17;
-  (*settings)["precisionType"] = "significant";
-  //! [StreamWriterBuilderDefaults]
-}
-
-String writeString(StreamWriter::Factory const& factory, Value const& root) {
-  OStringStream sout;
-  StreamWriterPtr const writer(factory.newStreamWriter());
-  writer->write(root, &sout);
-  return sout.str();
-}
-
-OStream& operator<<(OStream& sout, Value const& root) {
-  StreamWriterBuilder builder;
-  StreamWriterPtr const writer(builder.newStreamWriter());
-  writer->write(root, &sout);
-  return sout;
-}
-
-} // namespace Json
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: src/lib_json/json_writer.cpp
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
diff --git a/Modules/CppMicroServices/third_party/jsoncpp.h b/Modules/CppMicroServices/third_party/jsoncpp.h
deleted file mode 100644
index b280790a4e..0000000000
--- a/Modules/CppMicroServices/third_party/jsoncpp.h
+++ /dev/null
@@ -1,2346 +0,0 @@
-/// Json-cpp amalgamated header (http://jsoncpp.sourceforge.net/).
-/// It is intended to be used with #include "json/json.h"
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-/*
-The JsonCpp library's source code, including accompanying documentation,
-tests and demonstration applications, are licensed under the following
-conditions...
-
-Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all
-jurisdictions which recognize such a disclaimer. In such jurisdictions,
-this software is released into the Public Domain.
-
-In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
-2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
-The JsonCpp Authors, and is released under the terms of the MIT License (see below).
-
-In jurisdictions which recognize Public Domain property, the user of this
-software may choose to accept it either as 1) Public Domain, 2) under the
-conditions of the MIT License (see below), or 3) under the terms of dual
-Public Domain/MIT License conditions described here, as they choose.
-
-The MIT License is about as close to Public Domain as a license can get, and is
-described in clear, concise terms at:
-
-   http://en.wikipedia.org/wiki/MIT_License
-
-The full text of the MIT License follows:
-
-========================================================================
-Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use, copy,
-modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-========================================================================
-(END LICENSE TEXT)
-
-The MIT license is compatible with both the GPL and commercial
-software, affording one all of the rights of Public Domain with the
-minor nuisance of being required to keep the above copyright notice
-and license text in the source code. Note also that by accepting the
-Public Domain "license" you can re-license your copy using whatever
-license you like.
-
-*/
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-#ifndef JSON_AMALGAMATED_H_INCLUDED
-# define JSON_AMALGAMATED_H_INCLUDED
-/// If defined, indicates that the source file is amalgamated
-/// to prevent private header inclusion.
-#define JSON_IS_AMALGAMATION
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/version.h
-// //////////////////////////////////////////////////////////////////////
-
-#ifndef JSON_VERSION_H_INCLUDED
-#define JSON_VERSION_H_INCLUDED
-
-// Note: version must be updated in three places when doing a release. This
-// annoying process ensures that amalgamate, CMake, and meson all report the
-// correct version.
-// 1. /meson.build
-// 2. /include/json/version.h
-// 3. /CMakeLists.txt
-// IMPORTANT: also update the SOVERSION!!
-
-#define JSONCPP_VERSION_STRING "1.9.5"
-#define JSONCPP_VERSION_MAJOR 1
-#define JSONCPP_VERSION_MINOR 9
-#define JSONCPP_VERSION_PATCH 5
-#define JSONCPP_VERSION_QUALIFIER
-#define JSONCPP_VERSION_HEXA                                                   \
-  ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) |             \
-   (JSONCPP_VERSION_PATCH << 8))
-
-#ifdef JSONCPP_USING_SECURE_MEMORY
-#undef JSONCPP_USING_SECURE_MEMORY
-#endif
-#define JSONCPP_USING_SECURE_MEMORY 0
-// If non-zero, the library zeroes any memory that it has allocated before
-// it frees its memory.
-
-#endif // JSON_VERSION_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/version.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/allocator.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_ALLOCATOR_H_INCLUDED
-#define JSON_ALLOCATOR_H_INCLUDED
-
-#include <cstring>
-#include <memory>
-
-#pragma pack(push, 8)
-
-namespace Json {
-template <typename T> class SecureAllocator {
-public:
-  // Type definitions
-  using value_type = T;
-  using pointer = T*;
-  using const_pointer = const T*;
-  using reference = T&;
-  using const_reference = const T&;
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
-
-  /**
-   * Allocate memory for N items using the standard allocator.
-   */
-  pointer allocate(size_type n) {
-    // allocate using "global operator new"
-    return static_cast<pointer>(::operator new(n * sizeof(T)));
-  }
-
-  /**
-   * Release memory which was allocated for N items at pointer P.
-   *
-   * The memory block is filled with zeroes before being released.
-   */
-  void deallocate(pointer p, size_type n) {
-    // memset_s is used because memset may be optimized away by the compiler
-    memset_s(p, n * sizeof(T), 0, n * sizeof(T));
-    // free using "global operator delete"
-    ::operator delete(p);
-  }
-
-  /**
-   * Construct an item in-place at pointer P.
-   */
-  template <typename... Args> void construct(pointer p, Args&&... args) {
-    // construct using "placement new" and "perfect forwarding"
-    ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
-  }
-
-  size_type max_size() const { return size_t(-1) / sizeof(T); }
-
-  pointer address(reference x) const { return std::addressof(x); }
-
-  const_pointer address(const_reference x) const { return std::addressof(x); }
-
-  /**
-   * Destroy an item in-place at pointer P.
-   */
-  void destroy(pointer p) {
-    // destroy using "explicit destructor"
-    p->~T();
-  }
-
-  // Boilerplate
-  SecureAllocator() {}
-  template <typename U> SecureAllocator(const SecureAllocator<U>&) {}
-  template <typename U> struct rebind { using other = SecureAllocator<U>; };
-};
-
-template <typename T, typename U>
-bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&) {
-  return true;
-}
-
-template <typename T, typename U>
-bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&) {
-  return false;
-}
-
-} // namespace Json
-
-#pragma pack(pop)
-
-#endif // JSON_ALLOCATOR_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/allocator.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/config.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_CONFIG_H_INCLUDED
-#define JSON_CONFIG_H_INCLUDED
-#include <cstddef>
-#include <cstdint>
-#include <istream>
-#include <memory>
-#include <ostream>
-#include <sstream>
-#include <string>
-#include <type_traits>
-
-// If non-zero, the library uses exceptions to report bad input instead of C
-// assertion macros. The default is to use exceptions.
-#ifndef JSON_USE_EXCEPTION
-#define JSON_USE_EXCEPTION 1
-#endif
-
-// Temporary, tracked for removal with issue #982.
-#ifndef JSON_USE_NULLREF
-#define JSON_USE_NULLREF 1
-#endif
-
-/// If defined, indicates that the source file is amalgamated
-/// to prevent private header inclusion.
-/// Remarks: it is automatically defined in the generated amalgamated header.
-// #define JSON_IS_AMALGAMATION
-
-// Export macros for DLL visibility
-#if defined(JSON_DLL_BUILD)
-#if defined(_MSC_VER) || defined(__MINGW32__)
-#define JSON_API __declspec(dllexport)
-#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
-#elif defined(__GNUC__) || defined(__clang__)
-#define JSON_API __attribute__((visibility("default")))
-#endif // if defined(_MSC_VER)
-
-#elif defined(JSON_DLL)
-#if defined(_MSC_VER) || defined(__MINGW32__)
-#define JSON_API __declspec(dllimport)
-#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
-#endif // if defined(_MSC_VER)
-#endif // ifdef JSON_DLL_BUILD
-
-#if !defined(JSON_API)
-#define JSON_API
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER < 1800
-#error                                                                         \
-    "ERROR:  Visual Studio 12 (2013) with _MSC_VER=1800 is the oldest supported compiler with sufficient C++11 capabilities"
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER < 1900
-// As recommended at
-// https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
-extern JSON_API int msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
-                                              const char* format, ...);
-#define jsoncpp_snprintf msvc_pre1900_c99_snprintf
-#else
-#define jsoncpp_snprintf std::snprintf
-#endif
-
-// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
-// integer
-// Storages, and 64 bits integer support is disabled.
-// #define JSON_NO_INT64 1
-
-// JSONCPP_OVERRIDE is maintained for backwards compatibility of external tools.
-// C++11 should be used directly in JSONCPP.
-#define JSONCPP_OVERRIDE override
-
-#ifdef __clang__
-#if __has_extension(attribute_deprecated_with_message)
-#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
-#endif
-#elif defined(__GNUC__) // not clang (gcc comes later since clang emulates gcc)
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
-#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
-#elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
-#define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__))
-#endif                  // GNUC version
-#elif defined(_MSC_VER) // MSVC (after clang because clang on Windows emulates
-                        // MSVC)
-#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
-#endif // __clang__ || __GNUC__ || _MSC_VER
-
-#if !defined(JSONCPP_DEPRECATED)
-#define JSONCPP_DEPRECATED(message)
-#endif // if !defined(JSONCPP_DEPRECATED)
-
-#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6))
-#define JSON_USE_INT64_DOUBLE_CONVERSION 1
-#endif
-
-#if !defined(JSON_IS_AMALGAMATION)
-
-#include "allocator.h"
-#include "version.h"
-
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-namespace Json {
-using Int = int;
-using UInt = unsigned int;
-#if defined(JSON_NO_INT64)
-using LargestInt = int;
-using LargestUInt = unsigned int;
-#undef JSON_HAS_INT64
-#else                 // if defined(JSON_NO_INT64)
-// For Microsoft Visual use specific types as long long is not supported
-#if defined(_MSC_VER) // Microsoft Visual Studio
-using Int64 = __int64;
-using UInt64 = unsigned __int64;
-#else                 // if defined(_MSC_VER) // Other platforms, use long long
-using Int64 = int64_t;
-using UInt64 = uint64_t;
-#endif                // if defined(_MSC_VER)
-using LargestInt = Int64;
-using LargestUInt = UInt64;
-#define JSON_HAS_INT64
-#endif // if defined(JSON_NO_INT64)
-
-template <typename T>
-using Allocator =
-    typename std::conditional<JSONCPP_USING_SECURE_MEMORY, SecureAllocator<T>,
-                              std::allocator<T>>::type;
-using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
-using IStringStream =
-    std::basic_istringstream<String::value_type, String::traits_type,
-                             String::allocator_type>;
-using OStringStream =
-    std::basic_ostringstream<String::value_type, String::traits_type,
-                             String::allocator_type>;
-using IStream = std::istream;
-using OStream = std::ostream;
-} // namespace Json
-
-// Legacy names (formerly macros).
-using JSONCPP_STRING = Json::String;
-using JSONCPP_ISTRINGSTREAM = Json::IStringStream;
-using JSONCPP_OSTRINGSTREAM = Json::OStringStream;
-using JSONCPP_ISTREAM = Json::IStream;
-using JSONCPP_OSTREAM = Json::OStream;
-
-#endif // JSON_CONFIG_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/config.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/forwards.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_FORWARDS_H_INCLUDED
-#define JSON_FORWARDS_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "config.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-namespace Json {
-
-// writer.h
-class StreamWriter;
-class StreamWriterBuilder;
-class Writer;
-class FastWriter;
-class StyledWriter;
-class StyledStreamWriter;
-
-// reader.h
-class Reader;
-class CharReader;
-class CharReaderBuilder;
-
-// json_features.h
-class Features;
-
-// value.h
-using ArrayIndex = unsigned int;
-class StaticString;
-class Path;
-class PathArgument;
-class Value;
-class ValueIteratorBase;
-class ValueIterator;
-class ValueConstIterator;
-
-} // namespace Json
-
-#endif // JSON_FORWARDS_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/forwards.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/json_features.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_FEATURES_H_INCLUDED
-#define JSON_FEATURES_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "forwards.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-#pragma pack(push, 8)
-
-namespace Json {
-
-/** \brief Configuration passed to reader and writer.
- * This configuration object can be used to force the Reader or Writer
- * to behave in a standard conforming way.
- */
-class JSON_API Features {
-public:
-  /** \brief A configuration that allows all features and assumes all strings
-   * are UTF-8.
-   * - C & C++ comments are allowed
-   * - Root object can be any JSON value
-   * - Assumes Value strings are encoded in UTF-8
-   */
-  static Features all();
-
-  /** \brief A configuration that is strictly compatible with the JSON
-   * specification.
-   * - Comments are forbidden.
-   * - Root object must be either an array or an object value.
-   * - Assumes Value strings are encoded in UTF-8
-   */
-  static Features strictMode();
-
-  /** \brief Initialize the configuration like JsonConfig::allFeatures;
-   */
-  Features();
-
-  /// \c true if comments are allowed. Default: \c true.
-  bool allowComments_{true};
-
-  /// \c true if root must be either an array or an object value. Default: \c
-  /// false.
-  bool strictRoot_{false};
-
-  /// \c true if dropped null placeholders are allowed. Default: \c false.
-  bool allowDroppedNullPlaceholders_{false};
-
-  /// \c true if numeric object key are allowed. Default: \c false.
-  bool allowNumericKeys_{false};
-};
-
-} // namespace Json
-
-#pragma pack(pop)
-
-#endif // JSON_FEATURES_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/json_features.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/value.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_H_INCLUDED
-#define JSON_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "forwards.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-// Conditional NORETURN attribute on the throw functions would:
-// a) suppress false positives from static code analysis
-// b) possibly improve optimization opportunities.
-#if !defined(JSONCPP_NORETURN)
-#if defined(_MSC_VER) && _MSC_VER == 1800
-#define JSONCPP_NORETURN __declspec(noreturn)
-#else
-#define JSONCPP_NORETURN [[noreturn]]
-#endif
-#endif
-
-// Support for '= delete' with template declarations was a late addition
-// to the c++11 standard and is rejected by clang 3.8 and Apple clang 8.2
-// even though these declare themselves to be c++11 compilers.
-#if !defined(JSONCPP_TEMPLATE_DELETE)
-#if defined(__clang__) && defined(__apple_build_version__)
-#if __apple_build_version__ <= 8000042
-#define JSONCPP_TEMPLATE_DELETE
-#endif
-#elif defined(__clang__)
-#if __clang_major__ == 3 && __clang_minor__ <= 8
-#define JSONCPP_TEMPLATE_DELETE
-#endif
-#endif
-#if !defined(JSONCPP_TEMPLATE_DELETE)
-#define JSONCPP_TEMPLATE_DELETE = delete
-#endif
-#endif
-
-#include <array>
-#include <exception>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-// Disable warning C4251: <data member>: <type> needs to have dll-interface to
-// be used by...
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(push)
-#pragma warning(disable : 4251 4275)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-#pragma pack(push, 8)
-
-/** \brief JSON (JavaScript Object Notation).
- */
-namespace Json {
-
-#if JSON_USE_EXCEPTION
-/** Base class for all exceptions we throw.
- *
- * We use nothing but these internally. Of course, STL can throw others.
- */
-class JSON_API Exception : public std::exception {
-public:
-  Exception(String msg);
-  ~Exception() noexcept override;
-  char const* what() const noexcept override;
-
-protected:
-  String msg_;
-};
-
-/** Exceptions which the user cannot easily avoid.
- *
- * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
- *
- * \remark derived from Json::Exception
- */
-class JSON_API RuntimeError : public Exception {
-public:
-  RuntimeError(String const& msg);
-};
-
-/** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
- *
- * These are precondition-violations (user bugs) and internal errors (our bugs).
- *
- * \remark derived from Json::Exception
- */
-class JSON_API LogicError : public Exception {
-public:
-  LogicError(String const& msg);
-};
-#endif
-
-/// used internally
-JSONCPP_NORETURN void throwRuntimeError(String const& msg);
-/// used internally
-JSONCPP_NORETURN void throwLogicError(String const& msg);
-
-/** \brief Type of the value held by a Value object.
- */
-enum ValueType {
-  nullValue = 0, ///< 'null' value
-  intValue,      ///< signed integer value
-  uintValue,     ///< unsigned integer value
-  realValue,     ///< double value
-  stringValue,   ///< UTF-8 string value
-  booleanValue,  ///< bool value
-  arrayValue,    ///< array value (ordered list)
-  objectValue    ///< object value (collection of name/value pairs).
-};
-
-enum CommentPlacement {
-  commentBefore = 0,      ///< a comment placed on the line before a value
-  commentAfterOnSameLine, ///< a comment just after a value on the same line
-  commentAfter, ///< a comment on the line after a value (only make sense for
-  /// root value)
-  numberOfCommentPlacement
-};
-
-/** \brief Type of precision for formatting of real values.
- */
-enum PrecisionType {
-  significantDigits = 0, ///< we set max number of significant digits in string
-  decimalPlaces          ///< we set max number of digits after "." in string
-};
-
-/** \brief Lightweight wrapper to tag static string.
- *
- * Value constructor and objectValue member assignment takes advantage of the
- * StaticString and avoid the cost of string duplication when storing the
- * string or the member name.
- *
- * Example of usage:
- * \code
- * Json::Value aValue( StaticString("some text") );
- * Json::Value object;
- * static const StaticString code("code");
- * object[code] = 1234;
- * \endcode
- */
-class JSON_API StaticString {
-public:
-  explicit StaticString(const char* czstring) : c_str_(czstring) {}
-
-  operator const char*() const { return c_str_; }
-
-  const char* c_str() const { return c_str_; }
-
-private:
-  const char* c_str_;
-};
-
-/** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
- *
- * This class is a discriminated union wrapper that can represents a:
- * - signed integer [range: Value::minInt - Value::maxInt]
- * - unsigned integer (range: 0 - Value::maxUInt)
- * - double
- * - UTF-8 string
- * - boolean
- * - 'null'
- * - an ordered list of Value
- * - collection of name/value pairs (javascript object)
- *
- * The type of the held value is represented by a #ValueType and
- * can be obtained using type().
- *
- * Values of an #objectValue or #arrayValue can be accessed using operator[]()
- * methods.
- * Non-const methods will automatically create the a #nullValue element
- * if it does not exist.
- * The sequence of an #arrayValue will be automatically resized and initialized
- * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
- *
- * The get() methods can be used to obtain default value in the case the
- * required element does not exist.
- *
- * It is possible to iterate over the list of member keys of an object using
- * the getMemberNames() method.
- *
- * \note #Value string-length fit in size_t, but keys must be < 2^30.
- * (The reason is an implementation detail.) A #CharReader will raise an
- * exception if a bound is exceeded to avoid security holes in your app,
- * but the Value API does *not* check bounds. That is the responsibility
- * of the caller.
- */
-class JSON_API Value {
-  friend class ValueIteratorBase;
-
-public:
-  using Members = std::vector<String>;
-  using iterator = ValueIterator;
-  using const_iterator = ValueConstIterator;
-  using UInt = Json::UInt;
-  using Int = Json::Int;
-#if defined(JSON_HAS_INT64)
-  using UInt64 = Json::UInt64;
-  using Int64 = Json::Int64;
-#endif // defined(JSON_HAS_INT64)
-  using LargestInt = Json::LargestInt;
-  using LargestUInt = Json::LargestUInt;
-  using ArrayIndex = Json::ArrayIndex;
-
-  // Required for boost integration, e. g. BOOST_TEST
-  using value_type = std::string;
-
-#if JSON_USE_NULLREF
-  // Binary compatibility kludges, do not use.
-  static const Value& null;
-  static const Value& nullRef;
-#endif
-
-  // null and nullRef are deprecated, use this instead.
-  static Value const& nullSingleton();
-
-  /// Minimum signed integer value that can be stored in a Json::Value.
-  static constexpr LargestInt minLargestInt =
-      LargestInt(~(LargestUInt(-1) / 2));
-  /// Maximum signed integer value that can be stored in a Json::Value.
-  static constexpr LargestInt maxLargestInt = LargestInt(LargestUInt(-1) / 2);
-  /// Maximum unsigned integer value that can be stored in a Json::Value.
-  static constexpr LargestUInt maxLargestUInt = LargestUInt(-1);
-
-  /// Minimum signed int value that can be stored in a Json::Value.
-  static constexpr Int minInt = Int(~(UInt(-1) / 2));
-  /// Maximum signed int value that can be stored in a Json::Value.
-  static constexpr Int maxInt = Int(UInt(-1) / 2);
-  /// Maximum unsigned int value that can be stored in a Json::Value.
-  static constexpr UInt maxUInt = UInt(-1);
-
-#if defined(JSON_HAS_INT64)
-  /// Minimum signed 64 bits int value that can be stored in a Json::Value.
-  static constexpr Int64 minInt64 = Int64(~(UInt64(-1) / 2));
-  /// Maximum signed 64 bits int value that can be stored in a Json::Value.
-  static constexpr Int64 maxInt64 = Int64(UInt64(-1) / 2);
-  /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
-  static constexpr UInt64 maxUInt64 = UInt64(-1);
-#endif // defined(JSON_HAS_INT64)
-  /// Default precision for real value for string representation.
-  static constexpr UInt defaultRealPrecision = 17;
-  // The constant is hard-coded because some compiler have trouble
-  // converting Value::maxUInt64 to a double correctly (AIX/xlC).
-  // Assumes that UInt64 is a 64 bits integer.
-  static constexpr double maxUInt64AsDouble = 18446744073709551615.0;
-// Workaround for bug in the NVIDIAs CUDA 9.1 nvcc compiler
-// when using gcc and clang backend compilers.  CZString
-// cannot be defined as private.  See issue #486
-#ifdef __NVCC__
-public:
-#else
-private:
-#endif
-#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-  class CZString {
-  public:
-    enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
-    CZString(ArrayIndex index);
-    CZString(char const* str, unsigned length, DuplicationPolicy allocate);
-    CZString(CZString const& other);
-    CZString(CZString&& other) noexcept;
-    ~CZString();
-    CZString& operator=(const CZString& other);
-    CZString& operator=(CZString&& other) noexcept;
-
-    bool operator<(CZString const& other) const;
-    bool operator==(CZString const& other) const;
-    ArrayIndex index() const;
-    // const char* c_str() const; ///< \deprecated
-    char const* data() const;
-    unsigned length() const;
-    bool isStaticString() const;
-
-  private:
-    void swap(CZString& other);
-
-    struct StringStorage {
-      unsigned policy_ : 2;
-      unsigned length_ : 30; // 1GB max
-    };
-
-    char const* cstr_; // actually, a prefixed string, unless policy is noDup
-    union {
-      ArrayIndex index_;
-      StringStorage storage_;
-    };
-  };
-
-public:
-  typedef std::map<CZString, Value> ObjectValues;
-#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-
-public:
-  /**
-   * \brief Create a default Value of the given type.
-   *
-   * This is a very useful constructor.
-   * To create an empty array, pass arrayValue.
-   * To create an empty object, pass objectValue.
-   * Another Value can then be set to this one by assignment.
-   * This is useful since clear() and resize() will not alter types.
-   *
-   * Examples:
-   *   \code
-   *   Json::Value null_value; // null
-   *   Json::Value arr_value(Json::arrayValue); // []
-   *   Json::Value obj_value(Json::objectValue); // {}
-   *   \endcode
-   */
-  Value(ValueType type = nullValue);
-  Value(Int value);
-  Value(UInt value);
-#if defined(JSON_HAS_INT64)
-  Value(Int64 value);
-  Value(UInt64 value);
-#endif // if defined(JSON_HAS_INT64)
-  Value(double value);
-  Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)
-  Value(const char* begin, const char* end); ///< Copy all, incl zeroes.
-  /**
-   * \brief Constructs a value from a static string.
-   *
-   * Like other value string constructor but do not duplicate the string for
-   * internal storage. The given string must remain alive after the call to
-   * this constructor.
-   *
-   * \note This works only for null-terminated strings. (We cannot change the
-   * size of this class, so we have nowhere to store the length, which might be
-   * computed later for various operations.)
-   *
-   * Example of usage:
-   *   \code
-   *   static StaticString foo("some text");
-   *   Json::Value aValue(foo);
-   *   \endcode
-   */
-  Value(const StaticString& value);
-  Value(const String& value);
-  Value(bool value);
-  Value(std::nullptr_t ptr) = delete;
-  Value(const Value& other);
-  Value(Value&& other) noexcept;
-  ~Value();
-
-  /// \note Overwrite existing comments. To preserve comments, use
-  /// #swapPayload().
-  Value& operator=(const Value& other);
-  Value& operator=(Value&& other) noexcept;
-
-  /// Swap everything.
-  void swap(Value& other);
-  /// Swap values but leave comments and source offsets in place.
-  void swapPayload(Value& other);
-
-  /// copy everything.
-  void copy(const Value& other);
-  /// copy values but leave comments and source offsets in place.
-  void copyPayload(const Value& other);
-
-  ValueType type() const;
-
-  /// Compare payload only, not comments etc.
-  bool operator<(const Value& other) const;
-  bool operator<=(const Value& other) const;
-  bool operator>=(const Value& other) const;
-  bool operator>(const Value& other) const;
-  bool operator==(const Value& other) const;
-  bool operator!=(const Value& other) const;
-  int compare(const Value& other) const;
-
-  const char* asCString() const; ///< Embedded zeroes could cause you trouble!
-#if JSONCPP_USING_SECURE_MEMORY
-  unsigned getCStringLength() const; // Allows you to understand the length of
-                                     // the CString
-#endif
-  String asString() const; ///< Embedded zeroes are possible.
-  /** Get raw char* of string-value.
-   *  \return false if !string. (Seg-fault if str or end are NULL.)
-   */
-  bool getString(char const** begin, char const** end) const;
-  Int asInt() const;
-  UInt asUInt() const;
-#if defined(JSON_HAS_INT64)
-  Int64 asInt64() const;
-  UInt64 asUInt64() const;
-#endif // if defined(JSON_HAS_INT64)
-  LargestInt asLargestInt() const;
-  LargestUInt asLargestUInt() const;
-  float asFloat() const;
-  double asDouble() const;
-  bool asBool() const;
-
-  bool isNull() const;
-  bool isBool() const;
-  bool isInt() const;
-  bool isInt64() const;
-  bool isUInt() const;
-  bool isUInt64() const;
-  bool isIntegral() const;
-  bool isDouble() const;
-  bool isNumeric() const;
-  bool isString() const;
-  bool isArray() const;
-  bool isObject() const;
-
-  /// The `as<T>` and `is<T>` member function templates and specializations.
-  template <typename T> T as() const JSONCPP_TEMPLATE_DELETE;
-  template <typename T> bool is() const JSONCPP_TEMPLATE_DELETE;
-
-  bool isConvertibleTo(ValueType other) const;
-
-  /// Number of values in array or object
-  ArrayIndex size() const;
-
-  /// \brief Return true if empty array, empty object, or null;
-  /// otherwise, false.
-  bool empty() const;
-
-  /// Return !isNull()
-  explicit operator bool() const;
-
-  /// Remove all object members and array elements.
-  /// \pre type() is arrayValue, objectValue, or nullValue
-  /// \post type() is unchanged
-  void clear();
-
-  /// Resize the array to newSize elements.
-  /// New elements are initialized to null.
-  /// May only be called on nullValue or arrayValue.
-  /// \pre type() is arrayValue or nullValue
-  /// \post type() is arrayValue
-  void resize(ArrayIndex newSize);
-
-  //@{
-  /// Access an array element (zero based index). If the array contains less
-  /// than index element, then null value are inserted in the array so that
-  /// its size is index+1.
-  /// (You may need to say 'value[0u]' to get your compiler to distinguish
-  /// this from the operator[] which takes a string.)
-  Value& operator[](ArrayIndex index);
-  Value& operator[](int index);
-  //@}
-
-  //@{
-  /// Access an array element (zero based index).
-  /// (You may need to say 'value[0u]' to get your compiler to distinguish
-  /// this from the operator[] which takes a string.)
-  const Value& operator[](ArrayIndex index) const;
-  const Value& operator[](int index) const;
-  //@}
-
-  /// If the array contains at least index+1 elements, returns the element
-  /// value, otherwise returns defaultValue.
-  Value get(ArrayIndex index, const Value& defaultValue) const;
-  /// Return true if index < size().
-  bool isValidIndex(ArrayIndex index) const;
-  /// \brief Append value to array at the end.
-  ///
-  /// Equivalent to jsonvalue[jsonvalue.size()] = value;
-  Value& append(const Value& value);
-  Value& append(Value&& value);
-
-  /// \brief Insert value in array at specific index
-  bool insert(ArrayIndex index, const Value& newValue);
-  bool insert(ArrayIndex index, Value&& newValue);
-
-  /// Access an object value by name, create a null member if it does not exist.
-  /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
-  /// Exceeding that will cause an exception.
-  Value& operator[](const char* key);
-  /// Access an object value by name, returns null if there is no member with
-  /// that name.
-  const Value& operator[](const char* key) const;
-  /// Access an object value by name, create a null member if it does not exist.
-  /// \param key may contain embedded nulls.
-  Value& operator[](const String& key);
-  /// Access an object value by name, returns null if there is no member with
-  /// that name.
-  /// \param key may contain embedded nulls.
-  const Value& operator[](const String& key) const;
-  /** \brief Access an object value by name, create a null member if it does not
-   * exist.
-   *
-   * If the object has no entry for that name, then the member name used to
-   * store the new entry is not duplicated.
-   * Example of use:
-   *   \code
-   *   Json::Value object;
-   *   static const StaticString code("code");
-   *   object[code] = 1234;
-   *   \endcode
-   */
-  Value& operator[](const StaticString& key);
-  /// Return the member named key if it exist, defaultValue otherwise.
-  /// \note deep copy
-  Value get(const char* key, const Value& defaultValue) const;
-  /// Return the member named key if it exist, defaultValue otherwise.
-  /// \note deep copy
-  /// \note key may contain embedded nulls.
-  Value get(const char* begin, const char* end,
-            const Value& defaultValue) const;
-  /// Return the member named key if it exist, defaultValue otherwise.
-  /// \note deep copy
-  /// \param key may contain embedded nulls.
-  Value get(const String& key, const Value& defaultValue) const;
-  /// Most general and efficient version of isMember()const, get()const,
-  /// and operator[]const
-  /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
-  Value const* find(char const* begin, char const* end) const;
-  /// Most general and efficient version of object-mutators.
-  /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
-  /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
-  Value* demand(char const* begin, char const* end);
-  /// \brief Remove and return the named member.
-  ///
-  /// Do nothing if it did not exist.
-  /// \pre type() is objectValue or nullValue
-  /// \post type() is unchanged
-  void removeMember(const char* key);
-  /// Same as removeMember(const char*)
-  /// \param key may contain embedded nulls.
-  void removeMember(const String& key);
-  /// Same as removeMember(const char* begin, const char* end, Value* removed),
-  /// but 'key' is null-terminated.
-  bool removeMember(const char* key, Value* removed);
-  /** \brief Remove the named map member.
-   *
-   *  Update 'removed' iff removed.
-   *  \param key may contain embedded nulls.
-   *  \return true iff removed (no exceptions)
-   */
-  bool removeMember(String const& key, Value* removed);
-  /// Same as removeMember(String const& key, Value* removed)
-  bool removeMember(const char* begin, const char* end, Value* removed);
-  /** \brief Remove the indexed array element.
-   *
-   *  O(n) expensive operations.
-   *  Update 'removed' iff removed.
-   *  \return true if removed (no exceptions)
-   */
-  bool removeIndex(ArrayIndex index, Value* removed);
-
-  /// Return true if the object has a member named key.
-  /// \note 'key' must be null-terminated.
-  bool isMember(const char* key) const;
-  /// Return true if the object has a member named key.
-  /// \param key may contain embedded nulls.
-  bool isMember(const String& key) const;
-  /// Same as isMember(String const& key)const
-  bool isMember(const char* begin, const char* end) const;
-
-  /// \brief Return a list of the member names.
-  ///
-  /// If null, return an empty list.
-  /// \pre type() is objectValue or nullValue
-  /// \post if type() was nullValue, it remains nullValue
-  Members getMemberNames() const;
-
-  /// \deprecated Always pass len.
-  JSONCPP_DEPRECATED("Use setComment(String const&) instead.")
-  void setComment(const char* comment, CommentPlacement placement) {
-    setComment(String(comment, strlen(comment)), placement);
-  }
-  /// Comments must be //... or /* ... */
-  void setComment(const char* comment, size_t len, CommentPlacement placement) {
-    setComment(String(comment, len), placement);
-  }
-  /// Comments must be //... or /* ... */
-  void setComment(String comment, CommentPlacement placement);
-  bool hasComment(CommentPlacement placement) const;
-  /// Include delimiters and embedded newlines.
-  String getComment(CommentPlacement placement) const;
-
-  String toStyledString() const;
-
-  const_iterator begin() const;
-  const_iterator end() const;
-
-  iterator begin();
-  iterator end();
-
-  // Accessors for the [start, limit) range of bytes within the JSON text from
-  // which this value was parsed, if any.
-  void setOffsetStart(ptrdiff_t start);
-  void setOffsetLimit(ptrdiff_t limit);
-  ptrdiff_t getOffsetStart() const;
-  ptrdiff_t getOffsetLimit() const;
-
-private:
-  void setType(ValueType v) {
-    bits_.value_type_ = static_cast<unsigned char>(v);
-  }
-  bool isAllocated() const { return bits_.allocated_; }
-  void setIsAllocated(bool v) { bits_.allocated_ = v; }
-
-  void initBasic(ValueType type, bool allocated = false);
-  void dupPayload(const Value& other);
-  void releasePayload();
-  void dupMeta(const Value& other);
-
-  Value& resolveReference(const char* key);
-  Value& resolveReference(const char* key, const char* end);
-
-  // struct MemberNamesTransform
-  //{
-  //   typedef const char *result_type;
-  //   const char *operator()( const CZString &name ) const
-  //   {
-  //      return name.c_str();
-  //   }
-  //};
-
-  union ValueHolder {
-    LargestInt int_;
-    LargestUInt uint_;
-    double real_;
-    bool bool_;
-    char* string_; // if allocated_, ptr to { unsigned, char[] }.
-    ObjectValues* map_;
-  } value_;
-
-  struct {
-    // Really a ValueType, but types should agree for bitfield packing.
-    unsigned int value_type_ : 8;
-    // Unless allocated_, string_ must be null-terminated.
-    unsigned int allocated_ : 1;
-  } bits_;
-
-  class Comments {
-  public:
-    Comments() = default;
-    Comments(const Comments& that);
-    Comments(Comments&& that) noexcept;
-    Comments& operator=(const Comments& that);
-    Comments& operator=(Comments&& that) noexcept;
-    bool has(CommentPlacement slot) const;
-    String get(CommentPlacement slot) const;
-    void set(CommentPlacement slot, String comment);
-
-  private:
-    using Array = std::array<String, numberOfCommentPlacement>;
-    std::unique_ptr<Array> ptr_;
-  };
-  Comments comments_;
-
-  // [start, limit) byte offsets in the source JSON text from which this Value
-  // was extracted.
-  ptrdiff_t start_;
-  ptrdiff_t limit_;
-};
-
-template <> inline bool Value::as<bool>() const { return asBool(); }
-template <> inline bool Value::is<bool>() const { return isBool(); }
-
-template <> inline Int Value::as<Int>() const { return asInt(); }
-template <> inline bool Value::is<Int>() const { return isInt(); }
-
-template <> inline UInt Value::as<UInt>() const { return asUInt(); }
-template <> inline bool Value::is<UInt>() const { return isUInt(); }
-
-#if defined(JSON_HAS_INT64)
-template <> inline Int64 Value::as<Int64>() const { return asInt64(); }
-template <> inline bool Value::is<Int64>() const { return isInt64(); }
-
-template <> inline UInt64 Value::as<UInt64>() const { return asUInt64(); }
-template <> inline bool Value::is<UInt64>() const { return isUInt64(); }
-#endif
-
-template <> inline double Value::as<double>() const { return asDouble(); }
-template <> inline bool Value::is<double>() const { return isDouble(); }
-
-template <> inline String Value::as<String>() const { return asString(); }
-template <> inline bool Value::is<String>() const { return isString(); }
-
-/// These `as` specializations are type conversions, and do not have a
-/// corresponding `is`.
-template <> inline float Value::as<float>() const { return asFloat(); }
-template <> inline const char* Value::as<const char*>() const {
-  return asCString();
-}
-
-/** \brief Experimental and untested: represents an element of the "path" to
- * access a node.
- */
-class JSON_API PathArgument {
-public:
-  friend class Path;
-
-  PathArgument();
-  PathArgument(ArrayIndex index);
-  PathArgument(const char* key);
-  PathArgument(String key);
-
-private:
-  enum Kind { kindNone = 0, kindIndex, kindKey };
-  String key_;
-  ArrayIndex index_{};
-  Kind kind_{kindNone};
-};
-
-/** \brief Experimental and untested: represents a "path" to access a node.
- *
- * Syntax:
- * - "." => root node
- * - ".[n]" => elements at index 'n' of root node (an array value)
- * - ".name" => member named 'name' of root node (an object value)
- * - ".name1.name2.name3"
- * - ".[0][1][2].name1[3]"
- * - ".%" => member name is provided as parameter
- * - ".[%]" => index is provided as parameter
- */
-class JSON_API Path {
-public:
-  Path(const String& path, const PathArgument& a1 = PathArgument(),
-       const PathArgument& a2 = PathArgument(),
-       const PathArgument& a3 = PathArgument(),
-       const PathArgument& a4 = PathArgument(),
-       const PathArgument& a5 = PathArgument());
-
-  const Value& resolve(const Value& root) const;
-  Value resolve(const Value& root, const Value& defaultValue) const;
-  /// Creates the "path" to access the specified node and returns a reference on
-  /// the node.
-  Value& make(Value& root) const;
-
-private:
-  using InArgs = std::vector<const PathArgument*>;
-  using Args = std::vector<PathArgument>;
-
-  void makePath(const String& path, const InArgs& in);
-  void addPathInArg(const String& path, const InArgs& in,
-                    InArgs::const_iterator& itInArg, PathArgument::Kind kind);
-  static void invalidPath(const String& path, int location);
-
-  Args args_;
-};
-
-/** \brief base class for Value iterators.
- *
- */
-class JSON_API ValueIteratorBase {
-public:
-  using iterator_category = std::bidirectional_iterator_tag;
-  using size_t = unsigned int;
-  using difference_type = int;
-  using SelfType = ValueIteratorBase;
-
-  bool operator==(const SelfType& other) const { return isEqual(other); }
-
-  bool operator!=(const SelfType& other) const { return !isEqual(other); }
-
-  difference_type operator-(const SelfType& other) const {
-    return other.computeDistance(*this);
-  }
-
-  /// Return either the index or the member name of the referenced value as a
-  /// Value.
-  Value key() const;
-
-  /// Return the index of the referenced Value, or -1 if it is not an
-  /// arrayValue.
-  UInt index() const;
-
-  /// Return the member name of the referenced Value, or "" if it is not an
-  /// objectValue.
-  /// \note Avoid `c_str()` on result, as embedded zeroes are possible.
-  String name() const;
-
-  /// Return the member name of the referenced Value. "" if it is not an
-  /// objectValue.
-  /// \deprecated This cannot be used for UTF-8 strings, since there can be
-  /// embedded nulls.
-  JSONCPP_DEPRECATED("Use `key = name();` instead.")
-  char const* memberName() const;
-  /// Return the member name of the referenced Value, or NULL if it is not an
-  /// objectValue.
-  /// \note Better version than memberName(). Allows embedded nulls.
-  char const* memberName(char const** end) const;
-
-protected:
-  /*! Internal utility functions to assist with implementing
-   *   other iterator functions. The const and non-const versions
-   *   of the "deref" protected methods expose the protected
-   *   current_ member variable in a way that can often be
-   *   optimized away by the compiler.
-   */
-  const Value& deref() const;
-  Value& deref();
-
-  void increment();
-
-  void decrement();
-
-  difference_type computeDistance(const SelfType& other) const;
-
-  bool isEqual(const SelfType& other) const;
-
-  void copy(const SelfType& other);
-
-private:
-  Value::ObjectValues::iterator current_;
-  // Indicates that iterator is for a null value.
-  bool isNull_{true};
-
-public:
-  // For some reason, BORLAND needs these at the end, rather
-  // than earlier. No idea why.
-  ValueIteratorBase();
-  explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
-};
-
-/** \brief const iterator for object and array value.
- *
- */
-class JSON_API ValueConstIterator : public ValueIteratorBase {
-  friend class Value;
-
-public:
-  using value_type = const Value;
-  // typedef unsigned int size_t;
-  // typedef int difference_type;
-  using reference = const Value&;
-  using pointer = const Value*;
-  using SelfType = ValueConstIterator;
-
-  ValueConstIterator();
-  ValueConstIterator(ValueIterator const& other);
-
-private:
-  /*! \internal Use by Value to create an iterator.
-   */
-  explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
-
-public:
-  SelfType& operator=(const ValueIteratorBase& other);
-
-  SelfType operator++(int) {
-    SelfType temp(*this);
-    ++*this;
-    return temp;
-  }
-
-  SelfType operator--(int) {
-    SelfType temp(*this);
-    --*this;
-    return temp;
-  }
-
-  SelfType& operator--() {
-    decrement();
-    return *this;
-  }
-
-  SelfType& operator++() {
-    increment();
-    return *this;
-  }
-
-  reference operator*() const { return deref(); }
-
-  pointer operator->() const { return &deref(); }
-};
-
-/** \brief Iterator for object and array value.
- */
-class JSON_API ValueIterator : public ValueIteratorBase {
-  friend class Value;
-
-public:
-  using value_type = Value;
-  using size_t = unsigned int;
-  using difference_type = int;
-  using reference = Value&;
-  using pointer = Value*;
-  using SelfType = ValueIterator;
-
-  ValueIterator();
-  explicit ValueIterator(const ValueConstIterator& other);
-  ValueIterator(const ValueIterator& other);
-
-private:
-  /*! \internal Use by Value to create an iterator.
-   */
-  explicit ValueIterator(const Value::ObjectValues::iterator& current);
-
-public:
-  SelfType& operator=(const SelfType& other);
-
-  SelfType operator++(int) {
-    SelfType temp(*this);
-    ++*this;
-    return temp;
-  }
-
-  SelfType operator--(int) {
-    SelfType temp(*this);
-    --*this;
-    return temp;
-  }
-
-  SelfType& operator--() {
-    decrement();
-    return *this;
-  }
-
-  SelfType& operator++() {
-    increment();
-    return *this;
-  }
-
-  /*! The return value of non-const iterators can be
-   *  changed, so the these functions are not const
-   *  because the returned references/pointers can be used
-   *  to change state of the base class.
-   */
-  reference operator*() const { return const_cast<reference>(deref()); }
-  pointer operator->() const { return const_cast<pointer>(&deref()); }
-};
-
-inline void swap(Value& a, Value& b) { a.swap(b); }
-
-} // namespace Json
-
-#pragma pack(pop)
-
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(pop)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-#endif // JSON_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/value.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/reader.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_READER_H_INCLUDED
-#define JSON_READER_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "json_features.h"
-#include "value.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <deque>
-#include <iosfwd>
-#include <istream>
-#include <stack>
-#include <string>
-
-// Disable warning C4251: <data member>: <type> needs to have dll-interface to
-// be used by...
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(push)
-#pragma warning(disable : 4251)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-#pragma pack(push, 8)
-
-namespace Json {
-
-/** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a
- * Value.
- *
- * \deprecated Use CharReader and CharReaderBuilder.
- */
-
-class JSON_API Reader {
-public:
-  using Char = char;
-  using Location = const Char*;
-
-  /** \brief An error tagged with where in the JSON text it was encountered.
-   *
-   * The offsets give the [start, limit) range of bytes within the text. Note
-   * that this is bytes, not codepoints.
-   */
-  struct StructuredError {
-    ptrdiff_t offset_start;
-    ptrdiff_t offset_limit;
-    String message;
-  };
-
-  /** \brief Constructs a Reader allowing all features for parsing.
-    * \deprecated Use CharReader and CharReaderBuilder.
-   */
-  Reader();
-
-  /** \brief Constructs a Reader allowing the specified feature set for parsing.
-    * \deprecated Use CharReader and CharReaderBuilder.
-   */
-  Reader(const Features& features);
-
-  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
-   * document.
-   *
-   * \param      document        UTF-8 encoded string containing the document
-   *                             to read.
-   * \param[out] root            Contains the root value of the document if it
-   *                             was successfully parsed.
-   * \param      collectComments \c true to collect comment and allow writing
-   *                             them back during serialization, \c false to
-   *                             discard comments.  This parameter is ignored
-   *                             if Features::allowComments_ is \c false.
-   * \return \c true if the document was successfully parsed, \c false if an
-   * error occurred.
-   */
-  bool parse(const std::string& document, Value& root,
-             bool collectComments = true);
-
-  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
-   * document.
-   *
-   * \param      beginDoc        Pointer on the beginning of the UTF-8 encoded
-   *                             string of the document to read.
-   * \param      endDoc          Pointer on the end of the UTF-8 encoded string
-   *                             of the document to read.  Must be >= beginDoc.
-   * \param[out] root            Contains the root value of the document if it
-   *                             was successfully parsed.
-   * \param      collectComments \c true to collect comment and allow writing
-   *                             them back during serialization, \c false to
-   *                             discard comments.  This parameter is ignored
-   *                             if Features::allowComments_ is \c false.
-   * \return \c true if the document was successfully parsed, \c false if an
-   * error occurred.
-   */
-  bool parse(const char* beginDoc, const char* endDoc, Value& root,
-             bool collectComments = true);
-
-  /// \brief Parse from input stream.
-  /// \see Json::operator>>(std::istream&, Json::Value&).
-  bool parse(IStream& is, Value& root, bool collectComments = true);
-
-  /** \brief Returns a user friendly string that list errors in the parsed
-   * document.
-   *
-   * \return Formatted error message with the list of errors with their
-   * location in the parsed document. An empty string is returned if no error
-   * occurred during parsing.
-   * \deprecated Use getFormattedErrorMessages() instead (typo fix).
-   */
-  JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.")
-  String getFormatedErrorMessages() const;
-
-  /** \brief Returns a user friendly string that list errors in the parsed
-   * document.
-   *
-   * \return Formatted error message with the list of errors with their
-   * location in the parsed document. An empty string is returned if no error
-   * occurred during parsing.
-   */
-  String getFormattedErrorMessages() const;
-
-  /** \brief Returns a vector of structured errors encountered while parsing.
-   *
-   * \return A (possibly empty) vector of StructuredError objects. Currently
-   * only one error can be returned, but the caller should tolerate multiple
-   * errors.  This can occur if the parser recovers from a non-fatal parse
-   * error and then encounters additional errors.
-   */
-  std::vector<StructuredError> getStructuredErrors() const;
-
-  /** \brief Add a semantic error message.
-   *
-   * \param value   JSON Value location associated with the error
-   * \param message The error message.
-   * \return \c true if the error was successfully added, \c false if the Value
-   * offset exceeds the document size.
-   */
-  bool pushError(const Value& value, const String& message);
-
-  /** \brief Add a semantic error message with extra context.
-   *
-   * \param value   JSON Value location associated with the error
-   * \param message The error message.
-   * \param extra   Additional JSON Value location to contextualize the error
-   * \return \c true if the error was successfully added, \c false if either
-   * Value offset exceeds the document size.
-   */
-  bool pushError(const Value& value, const String& message, const Value& extra);
-
-  /** \brief Return whether there are any errors.
-   *
-   * \return \c true if there are no errors to report \c false if errors have
-   * occurred.
-   */
-  bool good() const;
-
-private:
-  enum TokenType {
-    tokenEndOfStream = 0,
-    tokenObjectBegin,
-    tokenObjectEnd,
-    tokenArrayBegin,
-    tokenArrayEnd,
-    tokenString,
-    tokenNumber,
-    tokenTrue,
-    tokenFalse,
-    tokenNull,
-    tokenArraySeparator,
-    tokenMemberSeparator,
-    tokenComment,
-    tokenError
-  };
-
-  class Token {
-  public:
-    TokenType type_;
-    Location start_;
-    Location end_;
-  };
-
-  class ErrorInfo {
-  public:
-    Token token_;
-    String message_;
-    Location extra_;
-  };
-
-  using Errors = std::deque<ErrorInfo>;
-
-  bool readToken(Token& token);
-  void skipSpaces();
-  bool match(const Char* pattern, int patternLength);
-  bool readComment();
-  bool readCStyleComment();
-  bool readCppStyleComment();
-  bool readString();
-  void readNumber();
-  bool readValue();
-  bool readObject(Token& token);
-  bool readArray(Token& token);
-  bool decodeNumber(Token& token);
-  bool decodeNumber(Token& token, Value& decoded);
-  bool decodeString(Token& token);
-  bool decodeString(Token& token, String& decoded);
-  bool decodeDouble(Token& token);
-  bool decodeDouble(Token& token, Value& decoded);
-  bool decodeUnicodeCodePoint(Token& token, Location& current, Location end,
-                              unsigned int& unicode);
-  bool decodeUnicodeEscapeSequence(Token& token, Location& current,
-                                   Location end, unsigned int& unicode);
-  bool addError(const String& message, Token& token, Location extra = nullptr);
-  bool recoverFromError(TokenType skipUntilToken);
-  bool addErrorAndRecover(const String& message, Token& token,
-                          TokenType skipUntilToken);
-  void skipUntilSpace();
-  Value& currentValue();
-  Char getNextChar();
-  void getLocationLineAndColumn(Location location, int& line,
-                                int& column) const;
-  String getLocationLineAndColumn(Location location) const;
-  void addComment(Location begin, Location end, CommentPlacement placement);
-  void skipCommentTokens(Token& token);
-
-  static bool containsNewLine(Location begin, Location end);
-  static String normalizeEOL(Location begin, Location end);
-
-  using Nodes = std::stack<Value*>;
-  Nodes nodes_;
-  Errors errors_;
-  String document_;
-  Location begin_{};
-  Location end_{};
-  Location current_{};
-  Location lastValueEnd_{};
-  Value* lastValue_{};
-  String commentsBefore_;
-  Features features_;
-  bool collectComments_{};
-}; // Reader
-
-/** Interface for reading JSON from a char array.
- */
-class JSON_API CharReader {
-public:
-  virtual ~CharReader() = default;
-  /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
-   * document. The document must be a UTF-8 encoded string containing the
-   * document to read.
-   *
-   * \param      beginDoc Pointer on the beginning of the UTF-8 encoded string
-   *                      of the document to read.
-   * \param      endDoc   Pointer on the end of the UTF-8 encoded string of the
-   *                      document to read. Must be >= beginDoc.
-   * \param[out] root     Contains the root value of the document if it was
-   *                      successfully parsed.
-   * \param[out] errs     Formatted error messages (if not NULL) a user
-   *                      friendly string that lists errors in the parsed
-   *                      document.
-   * \return \c true if the document was successfully parsed, \c false if an
-   * error occurred.
-   */
-  virtual bool parse(char const* beginDoc, char const* endDoc, Value* root,
-                     String* errs) = 0;
-
-  class JSON_API Factory {
-  public:
-    virtual ~Factory() = default;
-    /** \brief Allocate a CharReader via operator new().
-     * \throw std::exception if something goes wrong (e.g. invalid settings)
-     */
-    virtual CharReader* newCharReader() const = 0;
-  }; // Factory
-};   // CharReader
-
-/** \brief Build a CharReader implementation.
- *
- * Usage:
- *   \code
- *   using namespace Json;
- *   CharReaderBuilder builder;
- *   builder["collectComments"] = false;
- *   Value value;
- *   String errs;
- *   bool ok = parseFromStream(builder, std::cin, &value, &errs);
- *   \endcode
- */
-class JSON_API CharReaderBuilder : public CharReader::Factory {
-public:
-  // Note: We use a Json::Value so that we can add data-members to this class
-  // without a major version bump.
-  /** Configuration of this builder.
-   * These are case-sensitive.
-   * Available settings (case-sensitive):
-   * - `"collectComments": false or true`
-   *   - true to collect comment and allow writing them back during
-   *     serialization, false to discard comments.  This parameter is ignored
-   *     if allowComments is false.
-   * - `"allowComments": false or true`
-   *   - true if comments are allowed.
-   * - `"allowTrailingCommas": false or true`
-   *   - true if trailing commas in objects and arrays are allowed.
-   * - `"strictRoot": false or true`
-   *   - true if root must be either an array or an object value
-   * - `"allowDroppedNullPlaceholders": false or true`
-   *   - true if dropped null placeholders are allowed. (See
-   *     StreamWriterBuilder.)
-   * - `"allowNumericKeys": false or true`
-   *   - true if numeric object keys are allowed.
-   * - `"allowSingleQuotes": false or true`
-   *   - true if '' are allowed for strings (both keys and values)
-   * - `"stackLimit": integer`
-   *   - Exceeding stackLimit (recursive depth of `readValue()`) will cause an
-   *     exception.
-   *   - This is a security issue (seg-faults caused by deeply nested JSON), so
-   *     the default is low.
-   * - `"failIfExtra": false or true`
-   *   - If true, `parse()` returns false when extra non-whitespace trails the
-   *     JSON value in the input string.
-   * - `"rejectDupKeys": false or true`
-   *   - If true, `parse()` returns false when a key is duplicated within an
-   *     object.
-   * - `"allowSpecialFloats": false or true`
-   *   - If true, special float values (NaNs and infinities) are allowed and
-   *     their values are lossfree restorable.
-   * - `"skipBom": false or true`
-   *   - If true, if the input starts with the Unicode byte order mark (BOM),
-   *     it is skipped.
-   *
-   * You can examine 'settings_` yourself to see the defaults. You can also
-   * write and read them just like any JSON Value.
-   * \sa setDefaults()
-   */
-  Json::Value settings_;
-
-  CharReaderBuilder();
-  ~CharReaderBuilder() override;
-
-  CharReader* newCharReader() const override;
-
-  /** \return true if 'settings' are legal and consistent;
-   *   otherwise, indicate bad settings via 'invalid'.
-   */
-  bool validate(Json::Value* invalid) const;
-
-  /** A simple way to update a specific setting.
-   */
-  Value& operator[](const String& key);
-
-  /** Called by ctor, but you can use this to reset settings_.
-   * \pre 'settings' != NULL (but Json::null is fine)
-   * \remark Defaults:
-   * \snippet src/lib_json/json_reader.cpp CharReaderBuilderDefaults
-   */
-  static void setDefaults(Json::Value* settings);
-  /** Same as old Features::strictMode().
-   * \pre 'settings' != NULL (but Json::null is fine)
-   * \remark Defaults:
-   * \snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode
-   */
-  static void strictMode(Json::Value* settings);
-};
-
-/** Consume entire stream and use its begin/end.
- * Someday we might have a real StreamReader, but for now this
- * is convenient.
- */
-bool JSON_API parseFromStream(CharReader::Factory const&, IStream&, Value* root,
-                              String* errs);
-
-/** \brief Read from 'sin' into 'root'.
- *
- * Always keep comments from the input JSON.
- *
- * This can be used to read a file into a particular sub-object.
- * For example:
- *   \code
- *   Json::Value root;
- *   cin >> root["dir"]["file"];
- *   cout << root;
- *   \endcode
- * Result:
- * \verbatim
- * {
- * "dir": {
- *    "file": {
- *    // The input stream JSON would be nested here.
- *    }
- * }
- * }
- * \endverbatim
- * \throw std::exception on parse error.
- * \see Json::operator<<()
- */
-JSON_API IStream& operator>>(IStream&, Value&);
-
-} // namespace Json
-
-#pragma pack(pop)
-
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(pop)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-#endif // JSON_READER_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/reader.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/writer.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_WRITER_H_INCLUDED
-#define JSON_WRITER_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "value.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <ostream>
-#include <string>
-#include <vector>
-
-// Disable warning C4251: <data member>: <type> needs to have dll-interface to
-// be used by...
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) && defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4251)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-#pragma pack(push, 8)
-
-namespace Json {
-
-class Value;
-
-/**
- *
- * Usage:
- *  \code
- *  using namespace Json;
- *  void writeToStdout(StreamWriter::Factory const& factory, Value const& value)
- * { std::unique_ptr<StreamWriter> const writer( factory.newStreamWriter());
- *    writer->write(value, &std::cout);
- *    std::cout << std::endl;  // add lf and flush
- *  }
- *  \endcode
- */
-class JSON_API StreamWriter {
-protected:
-  OStream* sout_; // not owned; will not delete
-public:
-  StreamWriter();
-  virtual ~StreamWriter();
-  /** Write Value into document as configured in sub-class.
-   *   Do not take ownership of sout, but maintain a reference during function.
-   *   \pre sout != NULL
-   *   \return zero on success (For now, we always return zero, so check the
-   *   stream instead.) \throw std::exception possibly, depending on
-   * configuration
-   */
-  virtual int write(Value const& root, OStream* sout) = 0;
-
-  /** \brief A simple abstract factory.
-   */
-  class JSON_API Factory {
-  public:
-    virtual ~Factory();
-    /** \brief Allocate a CharReader via operator new().
-     * \throw std::exception if something goes wrong (e.g. invalid settings)
-     */
-    virtual StreamWriter* newStreamWriter() const = 0;
-  }; // Factory
-};   // StreamWriter
-
-/** \brief Write into stringstream, then return string, for convenience.
- * A StreamWriter will be created from the factory, used, and then deleted.
- */
-String JSON_API writeString(StreamWriter::Factory const& factory,
-                            Value const& root);
-
-/** \brief Build a StreamWriter implementation.
-
-* Usage:
-*   \code
-*   using namespace Json;
-*   Value value = ...;
-*   StreamWriterBuilder builder;
-*   builder["commentStyle"] = "None";
-*   builder["indentation"] = "   ";  // or whatever you like
-*   std::unique_ptr<Json::StreamWriter> writer(
-*      builder.newStreamWriter());
-*   writer->write(value, &std::cout);
-*   std::cout << std::endl;  // add lf and flush
-*   \endcode
-*/
-class JSON_API StreamWriterBuilder : public StreamWriter::Factory {
-public:
-  // Note: We use a Json::Value so that we can add data-members to this class
-  // without a major version bump.
-  /** Configuration of this builder.
-   *  Available settings (case-sensitive):
-   *  - "commentStyle": "None" or "All"
-   *  - "indentation":  "<anything>".
-   *  - Setting this to an empty string also omits newline characters.
-   *  - "enableYAMLCompatibility": false or true
-   *  - slightly change the whitespace around colons
-   *  - "dropNullPlaceholders": false or true
-   *  - Drop the "null" string from the writer's output for nullValues.
-   *    Strictly speaking, this is not valid JSON. But when the output is being
-   *    fed to a browser's JavaScript, it makes for smaller output and the
-   *    browser can handle the output just fine.
-   *  - "useSpecialFloats": false or true
-   *  - If true, outputs non-finite floating point values in the following way:
-   *    NaN values as "NaN", positive infinity as "Infinity", and negative
-   *  infinity as "-Infinity".
-   *  - "precision": int
-   *  - Number of precision digits for formatting of real values.
-   *  - "precisionType": "significant"(default) or "decimal"
-   *  - Type of precision for formatting of real values.
-   *  - "emitUTF8": false or true
-   *  - If true, outputs raw UTF8 strings instead of escaping them.
-
-   *  You can examine 'settings_` yourself
-   *  to see the defaults. You can also write and read them just like any
-   *  JSON Value.
-   *  \sa setDefaults()
-   */
-  Json::Value settings_;
-
-  StreamWriterBuilder();
-  ~StreamWriterBuilder() override;
-
-  /**
-   * \throw std::exception if something goes wrong (e.g. invalid settings)
-   */
-  StreamWriter* newStreamWriter() const override;
-
-  /** \return true if 'settings' are legal and consistent;
-   *   otherwise, indicate bad settings via 'invalid'.
-   */
-  bool validate(Json::Value* invalid) const;
-  /** A simple way to update a specific setting.
-   */
-  Value& operator[](const String& key);
-
-  /** Called by ctor, but you can use this to reset settings_.
-   * \pre 'settings' != NULL (but Json::null is fine)
-   * \remark Defaults:
-   * \snippet src/lib_json/json_writer.cpp StreamWriterBuilderDefaults
-   */
-  static void setDefaults(Json::Value* settings);
-};
-
-/** \brief Abstract class for writers.
- * \deprecated Use StreamWriter. (And really, this is an implementation detail.)
- */
-class JSON_API Writer {
-public:
-  virtual ~Writer();
-
-  virtual String write(const Value& root) = 0;
-};
-
-/** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
- *without formatting (not human friendly).
- *
- * The JSON document is written in a single line. It is not intended for 'human'
- *consumption,
- * but may be useful to support feature such as RPC where bandwidth is limited.
- * \sa Reader, Value
- * \deprecated Use StreamWriterBuilder.
- */
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4996) // Deriving from deprecated class
-#endif
-class JSON_API FastWriter
-    : public Writer {
-public:
-  FastWriter();
-  ~FastWriter() override = default;
-
-  void enableYAMLCompatibility();
-
-  /** \brief Drop the "null" string from the writer's output for nullValues.
-   * Strictly speaking, this is not valid JSON. But when the output is being
-   * fed to a browser's JavaScript, it makes for smaller output and the
-   * browser can handle the output just fine.
-   */
-  void dropNullPlaceholders();
-
-  void omitEndingLineFeed();
-
-public: // overridden from Writer
-  String write(const Value& root) override;
-
-private:
-  void writeValue(const Value& value);
-
-  String document_;
-  bool yamlCompatibilityEnabled_{false};
-  bool dropNullPlaceholders_{false};
-  bool omitEndingLineFeed_{false};
-};
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
- *human friendly way.
- *
- * The rules for line break and indent are as follow:
- * - Object value:
- *     - if empty then print {} without indent and line break
- *     - if not empty the print '{', line break & indent, print one value per
- *line
- *       and then unindent and line break and print '}'.
- * - Array value:
- *     - if empty then print [] without indent and line break
- *     - if the array contains no object value, empty array or some other value
- *types,
- *       and all the values fit on one lines, then print the array on a single
- *line.
- *     - otherwise, it the values do not fit on one line, or the array contains
- *       object or non empty array, then print one value per line.
- *
- * If the Value have comments then they are outputed according to their
- *#CommentPlacement.
- *
- * \sa Reader, Value, Value::setComment()
- * \deprecated Use StreamWriterBuilder.
- */
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4996) // Deriving from deprecated class
-#endif
-class JSON_API
-    StyledWriter : public Writer {
-public:
-  StyledWriter();
-  ~StyledWriter() override = default;
-
-public: // overridden from Writer
-  /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
-   * \param root Value to serialize.
-   * \return String containing the JSON document that represents the root value.
-   */
-  String write(const Value& root) override;
-
-private:
-  void writeValue(const Value& value);
-  void writeArrayValue(const Value& value);
-  bool isMultilineArray(const Value& value);
-  void pushValue(const String& value);
-  void writeIndent();
-  void writeWithIndent(const String& value);
-  void indent();
-  void unindent();
-  void writeCommentBeforeValue(const Value& root);
-  void writeCommentAfterValueOnSameLine(const Value& root);
-  static bool hasCommentForValue(const Value& value);
-  static String normalizeEOL(const String& text);
-
-  using ChildValues = std::vector<String>;
-
-  ChildValues childValues_;
-  String document_;
-  String indentString_;
-  unsigned int rightMargin_{74};
-  unsigned int indentSize_{3};
-  bool addChildValues_{false};
-};
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
- human friendly way,
-     to a stream rather than to a string.
- *
- * The rules for line break and indent are as follow:
- * - Object value:
- *     - if empty then print {} without indent and line break
- *     - if not empty the print '{', line break & indent, print one value per
- line
- *       and then unindent and line break and print '}'.
- * - Array value:
- *     - if empty then print [] without indent and line break
- *     - if the array contains no object value, empty array or some other value
- types,
- *       and all the values fit on one lines, then print the array on a single
- line.
- *     - otherwise, it the values do not fit on one line, or the array contains
- *       object or non empty array, then print one value per line.
- *
- * If the Value have comments then they are outputed according to their
- #CommentPlacement.
- *
- * \sa Reader, Value, Value::setComment()
- * \deprecated Use StreamWriterBuilder.
- */
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4996) // Deriving from deprecated class
-#endif
-class JSON_API
-    StyledStreamWriter {
-public:
-  /**
-   * \param indentation Each level will be indented by this amount extra.
-   */
-  StyledStreamWriter(String indentation = "\t");
-  ~StyledStreamWriter() = default;
-
-public:
-  /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
-   * \param out Stream to write to. (Can be ostringstream, e.g.)
-   * \param root Value to serialize.
-   * \note There is no point in deriving from Writer, since write() should not
-   * return a value.
-   */
-  void write(OStream& out, const Value& root);
-
-private:
-  void writeValue(const Value& value);
-  void writeArrayValue(const Value& value);
-  bool isMultilineArray(const Value& value);
-  void pushValue(const String& value);
-  void writeIndent();
-  void writeWithIndent(const String& value);
-  void indent();
-  void unindent();
-  void writeCommentBeforeValue(const Value& root);
-  void writeCommentAfterValueOnSameLine(const Value& root);
-  static bool hasCommentForValue(const Value& value);
-  static String normalizeEOL(const String& text);
-
-  using ChildValues = std::vector<String>;
-
-  ChildValues childValues_;
-  OStream* document_;
-  String indentString_;
-  unsigned int rightMargin_{74};
-  String indentation_;
-  bool addChildValues_ : 1;
-  bool indented_ : 1;
-};
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#if defined(JSON_HAS_INT64)
-String JSON_API valueToString(Int value);
-String JSON_API valueToString(UInt value);
-#endif // if defined(JSON_HAS_INT64)
-String JSON_API valueToString(LargestInt value);
-String JSON_API valueToString(LargestUInt value);
-String JSON_API valueToString(
-    double value, unsigned int precision = Value::defaultRealPrecision,
-    PrecisionType precisionType = PrecisionType::significantDigits);
-String JSON_API valueToString(bool value);
-String JSON_API valueToQuotedString(const char* value);
-
-/// \brief Output using the StyledStreamWriter.
-/// \see Json::operator>>()
-JSON_API OStream& operator<<(OStream&, const Value& root);
-
-} // namespace Json
-
-#pragma pack(pop)
-
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(pop)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-#endif // JSON_WRITER_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/writer.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/assertions.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_ASSERTIONS_H_INCLUDED
-#define JSON_ASSERTIONS_H_INCLUDED
-
-#include <cstdlib>
-#include <sstream>
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "config.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-/** It should not be possible for a maliciously designed file to
- *  cause an abort() or seg-fault, so these macros are used only
- *  for pre-condition violations and internal logic errors.
- */
-#if JSON_USE_EXCEPTION
-
-// @todo <= add detail about condition in exception
-#define JSON_ASSERT(condition)                                                 \
-  do {                                                                         \
-    if (!(condition)) {                                                        \
-      Json::throwLogicError("assert json failed");                             \
-    }                                                                          \
-  } while (0)
-
-#define JSON_FAIL_MESSAGE(message)                                             \
-  do {                                                                         \
-    OStringStream oss;                                                         \
-    oss << message;                                                            \
-    Json::throwLogicError(oss.str());                                          \
-    abort();                                                                   \
-  } while (0)
-
-#else // JSON_USE_EXCEPTION
-
-#define JSON_ASSERT(condition) assert(condition)
-
-// The call to assert() will show the failure message in debug builds. In
-// release builds we abort, for a core-dump or debugger.
-#define JSON_FAIL_MESSAGE(message)                                             \
-  {                                                                            \
-    OStringStream oss;                                                         \
-    oss << message;                                                            \
-    assert(false && oss.str().c_str());                                        \
-    abort();                                                                   \
-  }
-
-#endif
-
-#define JSON_ASSERT_MESSAGE(condition, message)                                \
-  do {                                                                         \
-    if (!(condition)) {                                                        \
-      JSON_FAIL_MESSAGE(message);                                              \
-    }                                                                          \
-  } while (0)
-
-#endif // JSON_ASSERTIONS_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/assertions.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-#endif //ifndef JSON_AMALGAMATED_H_INCLUDED
diff --git a/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp b/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp
index df4fa8ed0a..5bac64360b 100644
--- a/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp
+++ b/Modules/DICOM/src/mitkDICOMImageBlockDescriptor.cpp
@@ -1,913 +1,912 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkDICOMImageBlockDescriptor.h"
 #include "mitkStringProperty.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkPropertyKeyPath.h"
 #include "mitkDICOMIOMetaInformationPropertyConstants.h"
 #include <gdcmUIDs.h>
 #include <vector>
 #include <gdcmVersion.h>
 #include <dcmtk/config/osconfig.h>
 
 mitk::DICOMImageBlockDescriptor::DICOMImageBlockDescriptor()
 : m_ReaderImplementationLevel( SOPClassUnknown )
 , m_PropertyList( PropertyList::New() )
 , m_TagCache( nullptr )
 , m_PropertiesOutOfDate( true )
 {
   m_PropertyFunctor = &mitk::DICOMImageBlockDescriptor::GetPropertyForDICOMValues;
 }
 
 mitk::DICOMImageBlockDescriptor::~DICOMImageBlockDescriptor()
 {
 }
 
 mitk::DICOMImageBlockDescriptor::DICOMImageBlockDescriptor( const DICOMImageBlockDescriptor& other )
 : m_ImageFrameList( other.m_ImageFrameList )
 , m_MitkImage( other.m_MitkImage )
 , m_SliceIsLoaded( other.m_SliceIsLoaded )
 , m_ReaderImplementationLevel( other.m_ReaderImplementationLevel )
 , m_TiltInformation( other.m_TiltInformation )
 , m_PropertyList( other.m_PropertyList->Clone() )
 , m_TagCache( other.m_TagCache )
 , m_PropertiesOutOfDate( other.m_PropertiesOutOfDate )
 , m_AdditionalTagMap(other.m_AdditionalTagMap)
 , m_FoundAdditionalTags(other.m_FoundAdditionalTags)
 , m_PropertyFunctor(other.m_PropertyFunctor)
 {
   if ( m_MitkImage )
   {
     m_MitkImage = m_MitkImage->Clone();
   }
 }
 
 mitk::DICOMImageBlockDescriptor& mitk::DICOMImageBlockDescriptor::
   operator=( const DICOMImageBlockDescriptor& other )
 {
   if ( this != &other )
   {
     m_ImageFrameList            = other.m_ImageFrameList;
     m_MitkImage                 = other.m_MitkImage;
     m_SliceIsLoaded             = other.m_SliceIsLoaded;
     m_ReaderImplementationLevel = other.m_ReaderImplementationLevel;
     m_TiltInformation           = other.m_TiltInformation;
 
     m_AdditionalTagMap = other.m_AdditionalTagMap;
     m_FoundAdditionalTags = other.m_FoundAdditionalTags;
     m_PropertyFunctor = other.m_PropertyFunctor;
 
     if ( other.m_PropertyList )
     {
       m_PropertyList = other.m_PropertyList->Clone();
     }
 
     if ( other.m_MitkImage )
     {
       m_MitkImage = other.m_MitkImage->Clone();
     }
 
     m_TagCache            = other.m_TagCache;
     m_PropertiesOutOfDate = other.m_PropertiesOutOfDate;
   }
   return *this;
 }
 
 mitk::DICOMTagList mitk::DICOMImageBlockDescriptor::GetTagsOfInterest()
 {
   DICOMTagList completeList;
 
   completeList.push_back( DICOMTag( 0x0018, 0x1164 ) ); // pixel spacing
   completeList.push_back( DICOMTag( 0x0028, 0x0030 ) ); // imager pixel spacing
 
   completeList.push_back( DICOMTag( 0x0008, 0x0018 ) ); // sop instance UID
   completeList.push_back( DICOMTag( 0x0008, 0x0016 ) ); // sop class UID
 
   completeList.push_back( DICOMTag( 0x0020, 0x0011 ) ); // series number
   completeList.push_back( DICOMTag( 0x0008, 0x1030 ) ); // study description
   completeList.push_back( DICOMTag( 0x0008, 0x103e ) ); // series description
   completeList.push_back( DICOMTag( 0x0008, 0x0060 ) ); // modality
   completeList.push_back( DICOMTag( 0x0018, 0x0024 ) ); // sequence name
   completeList.push_back( DICOMTag( 0x0020, 0x0037 ) ); // image orientation
 
   completeList.push_back( DICOMTag( 0x0020, 0x1041 ) ); // slice location
   completeList.push_back( DICOMTag( 0x0020, 0x0012 ) ); // acquisition number
   completeList.push_back( DICOMTag( 0x0020, 0x0013 ) ); // instance number
   completeList.push_back( DICOMTag( 0x0020, 0x0032 ) ); // image position patient
 
   completeList.push_back( DICOMTag( 0x0028, 0x1050 ) ); // window center
   completeList.push_back( DICOMTag( 0x0028, 0x1051 ) ); // window width
   completeList.push_back( DICOMTag( 0x0008, 0x0008 ) ); // image type
   completeList.push_back( DICOMTag( 0x0028, 0x0004 ) ); // photometric interpretation
 
   return completeList;
 }
 
 
 void mitk::DICOMImageBlockDescriptor::SetAdditionalTagsOfInterest(
   const AdditionalTagsMapType& tagMap)
 {
   m_AdditionalTagMap = tagMap;
 }
 
 
 void mitk::DICOMImageBlockDescriptor::SetTiltInformation( const GantryTiltInformation& info )
 {
   m_TiltInformation = info;
 }
 
 const mitk::GantryTiltInformation mitk::DICOMImageBlockDescriptor::GetTiltInformation() const
 {
   return m_TiltInformation;
 }
 
 void mitk::DICOMImageBlockDescriptor::SetImageFrameList( const DICOMImageFrameList& framelist )
 {
   m_ImageFrameList = framelist;
   m_SliceIsLoaded.resize( framelist.size() );
   m_SliceIsLoaded.assign( framelist.size(), false );
 
   m_PropertiesOutOfDate = true;
 }
 
 const mitk::DICOMImageFrameList& mitk::DICOMImageBlockDescriptor::GetImageFrameList() const
 {
   return m_ImageFrameList;
 }
 
 void mitk::DICOMImageBlockDescriptor::SetMitkImage( Image::Pointer image )
 {
   if ( m_MitkImage != image )
   {
     if ( m_TagCache.IsExpired() )
     {
       MITK_ERROR << "Unable to describe MITK image with properties without a tag-cache object!";
       m_MitkImage = nullptr;
       return;
     }
 
     if ( m_ImageFrameList.empty() )
     {
       MITK_ERROR << "Unable to describe MITK image with properties without a frame list!";
       m_MitkImage = nullptr;
       return;
     }
 
     // Should verify that the image matches m_ImageFrameList and m_TagCache
     // however, this is hard to do without re-analyzing all
     // TODO we should at least make sure that the number of frames is identical (plus rows/columns,
     // orientation)
     //      without gantry tilt correction, we can also check image origin
 
     m_MitkImage = this->DescribeImageWithProperties( this->FixupSpacing( image ) );
   }
 }
 
 mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::GetMitkImage() const
 {
   return m_MitkImage;
 }
 
 mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::FixupSpacing( Image* mitkImage )
 {
   if ( mitkImage )
   {
     Vector3D imageSpacing = mitkImage->GetGeometry()->GetSpacing();
 
     ScalarType desiredSpacingX = imageSpacing[0];
     ScalarType desiredSpacingY = imageSpacing[1];
     this->GetDesiredMITKImagePixelSpacing(
       desiredSpacingX, desiredSpacingY ); // prefer pixel spacing over imager pixel spacing
 
     if ( desiredSpacingX <= 0 || desiredSpacingY <= 0 )
     {
       return mitkImage;
     }
 
     MITK_DEBUG << "Loaded image with spacing " << imageSpacing[0] << ", " << imageSpacing[1];
     MITK_DEBUG << "Found correct spacing info " << desiredSpacingX << ", " << desiredSpacingY;
 
     imageSpacing[0] = desiredSpacingX;
     imageSpacing[1] = desiredSpacingY;
     mitkImage->GetGeometry()->SetSpacing( imageSpacing );
   }
 
   return mitkImage;
 }
 void mitk::DICOMImageBlockDescriptor::SetSliceIsLoaded( unsigned int index, bool isLoaded )
 {
   if ( index < m_SliceIsLoaded.size() )
   {
     m_SliceIsLoaded[index] = isLoaded;
   }
   else
   {
     std::stringstream ss;
     ss << "Index " << index << " out of range (" << m_SliceIsLoaded.size() << " indices reserved)";
     throw std::invalid_argument( ss.str() );
   }
 }
 
 bool mitk::DICOMImageBlockDescriptor::IsSliceLoaded( unsigned int index ) const
 {
   if ( index < m_SliceIsLoaded.size() )
   {
     return m_SliceIsLoaded[index];
   }
   else
   {
     std::stringstream ss;
     ss << "Index " << index << " out of range (" << m_SliceIsLoaded.size() << " indices reserved)";
     throw std::invalid_argument( ss.str() );
   }
 }
 
 bool mitk::DICOMImageBlockDescriptor::AllSlicesAreLoaded() const
 {
   bool allLoaded = true;
   for ( auto iter = m_SliceIsLoaded.cbegin(); iter != m_SliceIsLoaded.cend(); ++iter )
   {
     allLoaded &= *iter;
   }
 
   return allLoaded;
 }
 
 /*
    PS defined      IPS defined     PS==IPS
         0               0                     --> UNKNOWN spacing, loader will invent
         0               1                     --> spacing as at detector surface
         1               0                     --> spacing as in patient
         1               1             0       --> detector surface spacing CORRECTED for geometrical
    magnifications: spacing as in patient
         1               1             1       --> detector surface spacing NOT corrected for geometrical
    magnifications: spacing as at detector
 */
 mitk::PixelSpacingInterpretation mitk::DICOMImageBlockDescriptor::GetPixelSpacingInterpretation() const
 {
   if ( m_ImageFrameList.empty() || m_TagCache.IsExpired() )
   {
     MITK_ERROR << "Invalid call to GetPixelSpacingInterpretation. Need to have initialized tag-cache!";
     return SpacingUnknown;
   }
 
   const std::string pixelSpacing       = this->GetPixelSpacing();
   const std::string imagerPixelSpacing = this->GetImagerPixelSpacing();
 
   if ( pixelSpacing.empty() )
   {
     if ( imagerPixelSpacing.empty() )
     {
       return SpacingUnknown;
     }
     else
     {
       return SpacingAtDetector;
     }
   }
   else // Pixel Spacing defined
   {
     if ( imagerPixelSpacing.empty() )
     {
       return SpacingInPatient;
     }
     else if ( pixelSpacing != imagerPixelSpacing )
     {
       return SpacingInPatient;
     }
     else
     {
       return SpacingAtDetector;
     }
   }
 }
 
 std::string mitk::DICOMImageBlockDescriptor::GetPixelSpacing() const
 {
-  if ( m_ImageFrameList.empty() || m_TagCache.IsExpired() )
+  auto tagCache = m_TagCache.Lock();
+
+  if ( m_ImageFrameList.empty() || tagCache.IsNull() )
   {
     MITK_ERROR << "Invalid call to GetPixelSpacing. Need to have initialized tag-cache!";
     return std::string( "" );
   }
 
   static const DICOMTag tagPixelSpacing( 0x0028, 0x0030 );
-  return m_TagCache.Lock()->GetTagValue( m_ImageFrameList.front(), tagPixelSpacing ).value;
+  return tagCache->GetTagValue( m_ImageFrameList.front(), tagPixelSpacing ).value;
 }
 
 std::string mitk::DICOMImageBlockDescriptor::GetImagerPixelSpacing() const
 {
-  if ( m_ImageFrameList.empty() || m_TagCache.IsExpired() )
+  auto tagCache = m_TagCache.Lock();
+
+  if ( m_ImageFrameList.empty() || tagCache.IsNull() )
   {
     MITK_ERROR << "Invalid call to GetImagerPixelSpacing. Need to have initialized tag-cache!";
     return std::string( "" );
   }
 
   static const DICOMTag tagImagerPixelSpacing( 0x0018, 0x1164 );
-  return m_TagCache.Lock()->GetTagValue( m_ImageFrameList.front(), tagImagerPixelSpacing ).value;
+  return tagCache->GetTagValue( m_ImageFrameList.front(), tagImagerPixelSpacing ).value;
 }
 
 void mitk::DICOMImageBlockDescriptor::GetDesiredMITKImagePixelSpacing( ScalarType& spacingX,
                                                                        ScalarType& spacingY ) const
 {
   const std::string pixelSpacing = this->GetPixelSpacing();
   // preference for "in patient" pixel spacing
   if ( !DICOMStringToSpacing( pixelSpacing, spacingX, spacingY ) )
   {
     const std::string imagerPixelSpacing = this->GetImagerPixelSpacing();
     // fallback to "on detector" spacing
     if ( !DICOMStringToSpacing( imagerPixelSpacing, spacingX, spacingY ) )
     {
       // at this point we have no hints whether the spacing is correct
       // do a quick sanity check and either trust in the input or set both to 1
       // We assume neither spacing to be negative, zero or unexpectedly large for
       // medical images
       if (spacingX < mitk::eps || spacingX > 1000 || spacingY < mitk::eps || spacingY > 1000)
       {
         spacingX = spacingY = 1.0;
       }
     }
   }
 }
 
 void mitk::DICOMImageBlockDescriptor::SetProperty( const std::string& key, BaseProperty* value )
 {
   m_PropertyList->SetProperty( key, value );
 }
 
 mitk::BaseProperty* mitk::DICOMImageBlockDescriptor::GetProperty( const std::string& key ) const
 {
   this->UpdateImageDescribingProperties();
   return m_PropertyList->GetProperty( key );
 }
 
 std::string mitk::DICOMImageBlockDescriptor::GetPropertyAsString( const std::string& key ) const
 {
   this->UpdateImageDescribingProperties();
   const mitk::BaseProperty::Pointer property = m_PropertyList->GetProperty( key );
   if ( property.IsNotNull() )
   {
     return property->GetValueAsString();
   }
   else
   {
     return std::string( "" );
   }
 }
 
 void mitk::DICOMImageBlockDescriptor::SetFlag( const std::string& key, bool value )
 {
   m_PropertyList->ReplaceProperty( key, BoolProperty::New( value ) );
 }
 
 bool mitk::DICOMImageBlockDescriptor::GetFlag( const std::string& key, bool defaultValue ) const
 {
   this->UpdateImageDescribingProperties();
   BoolProperty::ConstPointer boolProp = dynamic_cast<BoolProperty*>( this->GetProperty( key ) );
   if ( boolProp.IsNotNull() )
   {
     return boolProp->GetValue();
   }
   else
   {
     return defaultValue;
   }
 }
 
 void mitk::DICOMImageBlockDescriptor::SetIntProperty( const std::string& key, int value )
 {
   m_PropertyList->ReplaceProperty( key, IntProperty::New( value ) );
 }
 
 int mitk::DICOMImageBlockDescriptor::GetIntProperty( const std::string& key, int defaultValue ) const
 {
   this->UpdateImageDescribingProperties();
   IntProperty::ConstPointer intProp = dynamic_cast<IntProperty*>( this->GetProperty( key ) );
   if ( intProp.IsNotNull() )
   {
     return intProp->GetValue();
   }
   else
   {
     return defaultValue;
   }
 }
 
 double mitk::DICOMImageBlockDescriptor::stringtodouble( const std::string& str ) const
 {
   double d;
   std::string trimmedstring( str );
   try
   {
     trimmedstring = trimmedstring.erase( trimmedstring.find_last_not_of( " \n\r\t" ) + 1 );
   }
   catch ( ... )
   {
     // no last not of
   }
 
   std::string firstcomponent( trimmedstring );
   try
   {
     firstcomponent = trimmedstring.erase( trimmedstring.find_first_of( "\\" ) );
   }
   catch ( ... )
   {
     // no last not of
   }
 
   std::istringstream converter( firstcomponent );
   if ( !firstcomponent.empty() && ( converter >> d ) && converter.eof() )
   {
     return d;
   }
   else
   {
     throw std::invalid_argument( "Argument is not a convertable number" );
   }
 }
 
 mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::DescribeImageWithProperties( Image* mitkImage )
 {
   // TODO: this is a collection of properties that have been provided by the
   // legacy DicomSeriesReader.
   // We should at some point clean up this collection and name them in a more
   // consistent way!
 
   if ( !mitkImage )
     return mitkImage;
 
   mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_FILES()), this->GetProperty("filenamesForSlices"));
   mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_PIXEL_SPACING_INTERPRETATION_STRING()),
     StringProperty::New(PixelSpacingInterpretationToString(this->GetPixelSpacingInterpretation())));
   mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_PIXEL_SPACING_INTERPRETATION()),
     GenericProperty<PixelSpacingInterpretation>::New(this->GetPixelSpacingInterpretation()));
   mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_IMPLEMENTATION_LEVEL_STRING()),
     StringProperty::New(ReaderImplementationLevelToString(m_ReaderImplementationLevel)));
   mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_IMPLEMENTATION_LEVEL()),
     GenericProperty<ReaderImplementationLevel>::New(m_ReaderImplementationLevel));
   mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_GANTRY_TILT_CORRECTED()),
     BoolProperty::New(this->GetTiltInformation().IsRegularGantryTilt()));
   mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_3D_plus_t()), BoolProperty::New(this->GetFlag("3D+t", false)));
   mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_GDCM()), StringProperty::New(gdcm::Version::GetVersion()));
   mitkImage->SetProperty(PropertyKeyPathToPropertyName(DICOMIOMetaInformationPropertyConstants::READER_DCMTK()), StringProperty::New(PACKAGE_VERSION));
 
   // get all found additional tags of interest
 
   for (const auto &tag : m_FoundAdditionalTags)
   {
     BaseProperty* prop = this->GetProperty(tag);
     if (prop)
     {
       mitkImage->SetProperty(tag.c_str(), prop);
     }
   }
 
   /////////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////////
   //// Deprecated properties should be removed sooner then later (see above)
   /////////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////////
 
   // first part: add some tags that describe individual slices
   // these propeties are defined at analysis time (see UpdateImageDescribingProperties())
 
   const char* propertyKeySliceLocation  = "dicom.image.0020.1041";
   const char* propertyKeyInstanceNumber = "dicom.image.0020.0013";
   const char* propertyKeySOPInstanceUID = "dicom.image.0008.0018";
 
   mitkImage->SetProperty( propertyKeySliceLocation, this->GetProperty( "sliceLocationForSlices" ) );
   mitkImage->SetProperty( propertyKeyInstanceNumber, this->GetProperty( "instanceNumberForSlices" ) );
   mitkImage->SetProperty( propertyKeySOPInstanceUID, this->GetProperty( "SOPInstanceUIDForSlices" ) );
   mitkImage->SetProperty( "files", this->GetProperty( "filenamesForSlices_deprecated" ) );
 
   // second part: add properties that describe the whole image block
   mitkImage->SetProperty( "dicomseriesreader.SOPClassUID", StringProperty::New( this->GetSOPClassUID() ) );
 
   mitkImage->SetProperty( "dicomseriesreader.SOPClass", StringProperty::New( this->GetSOPClassUIDAsName() ) );
 
   mitkImage->SetProperty(
     "dicomseriesreader.PixelSpacingInterpretationString",
     StringProperty::New( PixelSpacingInterpretationToString( this->GetPixelSpacingInterpretation() ) ) );
   mitkImage->SetProperty(
     "dicomseriesreader.PixelSpacingInterpretation",
     GenericProperty<PixelSpacingInterpretation>::New( this->GetPixelSpacingInterpretation() ) );
 
   mitkImage->SetProperty(
     "dicomseriesreader.ReaderImplementationLevelString",
     StringProperty::New( ReaderImplementationLevelToString( m_ReaderImplementationLevel ) ) );
 
   mitkImage->SetProperty( "dicomseriesreader.ReaderImplementationLevel",
                           GenericProperty<ReaderImplementationLevel>::New( m_ReaderImplementationLevel ) );
 
   mitkImage->SetProperty( "dicomseriesreader.GantyTiltCorrected",
                           BoolProperty::New( this->GetTiltInformation().IsRegularGantryTilt() ) );
 
   mitkImage->SetProperty( "dicomseriesreader.3D+t", BoolProperty::New( this->GetFlag( "3D+t", false ) ) );
 
   // level window
   const std::string windowCenter = this->GetPropertyAsString( "windowCenter" );
   const std::string windowWidth  = this->GetPropertyAsString( "windowWidth" );
   try
   {
     const double level  = stringtodouble( windowCenter );
     const double window = stringtodouble( windowWidth );
     mitkImage->SetProperty( "levelwindow", LevelWindowProperty::New( LevelWindow( level, window ) ) );
   }
   catch ( ... )
   {
     // nothing, no levelwindow to be predicted...
   }
 
   const std::string modality = this->GetPropertyAsString( "modality" );
   mitkImage->SetProperty( "modality", StringProperty::New( modality ) );
 
   mitkImage->SetProperty( "dicom.pixel.PhotometricInterpretation",
                           this->GetProperty( "photometricInterpretation" ) );
   mitkImage->SetProperty( "dicom.image.imagetype", this->GetProperty( "imagetype" ) );
 
   mitkImage->SetProperty( "dicom.study.StudyDescription", this->GetProperty( "studyDescription" ) );
   mitkImage->SetProperty( "dicom.series.SeriesDescription", this->GetProperty( "seriesDescription" ) );
 
   mitkImage->SetProperty( "dicom.pixel.Rows", this->GetProperty( "rows" ) );
   mitkImage->SetProperty( "dicom.pixel.Columns", this->GetProperty( "columns" ) );
 
   // fourth part: get something from ImageIO. BUT this needs to be created elsewhere. or not at all!
 
   return mitkImage;
 }
 
 void mitk::DICOMImageBlockDescriptor::SetReaderImplementationLevel( const ReaderImplementationLevel& level )
 {
   m_ReaderImplementationLevel = level;
 }
 
 mitk::ReaderImplementationLevel mitk::DICOMImageBlockDescriptor::GetReaderImplementationLevel() const
 {
   return m_ReaderImplementationLevel;
 }
 
 std::string mitk::DICOMImageBlockDescriptor::GetSOPClassUID() const
 {
-  if ( !m_ImageFrameList.empty() && !m_TagCache.IsExpired() )
+  auto tagCache = m_TagCache.Lock();
+
+  if ( !m_ImageFrameList.empty() && tagCache.IsNotNull() )
   {
     static const DICOMTag tagSOPClassUID( 0x0008, 0x0016 );
-    return m_TagCache.Lock()->GetTagValue( m_ImageFrameList.front(), tagSOPClassUID ).value;
+    return tagCache->GetTagValue( m_ImageFrameList.front(), tagSOPClassUID ).value;
   }
   else
   {
     MITK_ERROR
       << "Invalid call to DICOMImageBlockDescriptor::GetSOPClassUID(). Need to have initialized tag-cache!";
     return std::string( "" );
   }
 }
 
 std::string mitk::DICOMImageBlockDescriptor::GetSOPClassUIDAsName() const
 {
   if ( !m_ImageFrameList.empty() && !m_TagCache.IsExpired() )
   {
     gdcm::UIDs uidKnowledge;
     uidKnowledge.SetFromUID( this->GetSOPClassUID().c_str() );
 
     const char* name = uidKnowledge.GetName();
     if ( name )
     {
       return std::string( name );
     }
     else
     {
       return std::string( "" );
     }
   }
   else
   {
     MITK_ERROR << "Invalid call to DICOMImageBlockDescriptor::GetSOPClassUIDAsName(). Need to have "
                   "initialized tag-cache!";
     return std::string( "" );
   }
 }
 
 int mitk::DICOMImageBlockDescriptor::GetNumberOfTimeSteps() const
 {
   int result = 1;
   this->m_PropertyList->GetIntProperty("timesteps", result);
 
   return result;
 };
 
 int mitk::DICOMImageBlockDescriptor::GetNumberOfFramesPerTimeStep() const
 {
   const int numberOfTimesteps = this->GetNumberOfTimeSteps();
   int numberOfFramesPerTimestep = this->m_ImageFrameList.size() / numberOfTimesteps;
   assert(int(double((double)this->m_ImageFrameList.size() / (double)numberOfTimesteps))
     == numberOfFramesPerTimestep); // this should hold
 
   return numberOfFramesPerTimestep;
 };
 
 
 void mitk::DICOMImageBlockDescriptor::SetTagCache( DICOMTagCache* privateCache )
 {
   // this must only be used during loading and never afterwards
   m_TagCache = privateCache;
 }
 
 #define printPropertyRange( label, property_name )                                 \
   \
 {                                                                             \
     const std::string first = this->GetPropertyAsString( #property_name "First" ); \
     const std::string last  = this->GetPropertyAsString( #property_name "Last" );  \
     if ( !first.empty() || !last.empty() )                                         \
     {                                                                              \
       if ( first == last )                                                         \
       {                                                                            \
         os << "  " label ": '" << first << "'" << std::endl;                       \
       }                                                                            \
       else                                                                         \
       {                                                                            \
         os << "  " label ": '" << first << "' - '" << last << "'" << std::endl;    \
       }                                                                            \
     }                                                                              \
   \
 }
 
 #define printProperty( label, property_name )                              \
   \
 {                                                                     \
     const std::string first = this->GetPropertyAsString( #property_name ); \
     if ( !first.empty() )                                                  \
     {                                                                      \
       os << "  " label ": '" << first << "'" << std::endl;                 \
     }                                                                      \
   \
 }
 
 #define printBool( label, commands )                                           \
   \
 {                                                                         \
     os << "  " label ": '" << ( commands ? "yes" : "no" ) << "'" << std::endl; \
   \
 }
 
 
 
 
 void mitk::DICOMImageBlockDescriptor::Print(std::ostream& os, bool filenameDetails) const
 {
   os << "  Number of Frames: '" << m_ImageFrameList.size() << "'" << std::endl;
   os << "  SOP class: '" << this->GetSOPClassUIDAsName() << "'" << std::endl;
 
   printProperty( "Series Number", seriesNumber );
   printProperty( "Study Description", studyDescription );
   printProperty( "Series Description", seriesDescription );
   printProperty( "Modality", modality );
   printProperty( "Sequence Name", sequenceName );
 
   printPropertyRange( "Slice Location", sliceLocation );
   printPropertyRange( "Acquisition Number", acquisitionNumber );
   printPropertyRange( "Instance Number", instanceNumber );
   printPropertyRange( "Image Position", imagePositionPatient );
   printProperty( "Image Orientation", orientation );
 
   os << "  Pixel spacing interpretation: '"
      << PixelSpacingInterpretationToString( this->GetPixelSpacingInterpretation() ) << "'" << std::endl;
   printBool( "Gantry Tilt", this->GetTiltInformation().IsRegularGantryTilt() )
     // printBool("3D+t", this->GetFlag("3D+t",false))
 
     // os << "  MITK image loaded: '" << (this->GetMitkImage().IsNotNull() ? "yes" : "no") << "'" <<
     // std::endl;
     if ( filenameDetails )
   {
     os << "  Files in this image block:" << std::endl;
     for ( auto frameIter = m_ImageFrameList.begin(); frameIter != m_ImageFrameList.end(); ++frameIter )
     {
       os << "    " << ( *frameIter )->Filename;
       if ( ( *frameIter )->FrameNo > 0 )
       {
         os << ", " << ( *frameIter )->FrameNo;
       }
       os << std::endl;
     }
   }
 }
 
 #define storeTagValueToProperty( tag_name, tag_g, tag_e )                  \
   \
 {                                                                     \
     const DICOMTag t( tag_g, tag_e );                                      \
     const std::string tagValue = tagCache->GetTagValue( firstFrame, t ).value; \
     const_cast<DICOMImageBlockDescriptor*>( this )                         \
       ->SetProperty( #tag_name, StringProperty::New( tagValue ) );         \
   \
 }
 
 #define storeTagValueRangeToProperty( tag_name, tag_g, tag_e )                  \
   \
 {                                                                          \
     const DICOMTag t( tag_g, tag_e );                                           \
     const std::string tagValueFirst = tagCache->GetTagValue( firstFrame, t ).value; \
     const std::string tagValueLast  = tagCache->GetTagValue( lastFrame, t ).value;  \
     const_cast<DICOMImageBlockDescriptor*>( this )                              \
       ->SetProperty( #tag_name "First", StringProperty::New( tagValueFirst ) ); \
     const_cast<DICOMImageBlockDescriptor*>( this )                              \
       ->SetProperty( #tag_name "Last", StringProperty::New( tagValueLast ) );   \
   \
 }
 
 
 void mitk::DICOMImageBlockDescriptor::UpdateImageDescribingProperties() const
 {
   if ( !m_PropertiesOutOfDate )
     return;
 
   if ( !m_ImageFrameList.empty() )
   {
-    if ( m_TagCache.IsExpired() )
-    {
-      MITK_ERROR << "Invalid call to DICOMImageBlockDescriptor::UpdateImageDescribingProperties(). Need to "
-                    "have initialized tag-cache!";
-      return;
-    }
-
     auto tagCache = m_TagCache.Lock();
 
     if (tagCache.IsNull())
     {
       MITK_ERROR << "Invalid call to DICOMImageBlockDescriptor::UpdateImageDescribingProperties(). Need to "
         "have initialized tag-cache!";
       return;
     }
 
 
     const DICOMImageFrameInfo::Pointer firstFrame = m_ImageFrameList.front();
     const DICOMImageFrameInfo::Pointer lastFrame  = m_ImageFrameList.back();
 
     // see macros above
     storeTagValueToProperty( seriesNumber, 0x0020, 0x0011 );
     storeTagValueToProperty( studyDescription, 0x0008, 0x1030 );
     storeTagValueToProperty( seriesDescription, 0x0008, 0x103e );
     storeTagValueToProperty( modality, 0x0008, 0x0060 );
     storeTagValueToProperty( sequenceName, 0x0018, 0x0024 );
     storeTagValueToProperty( orientation, 0x0020, 0x0037 );
     storeTagValueToProperty( rows, 0x0028, 0x0010 );
     storeTagValueToProperty( columns, 0x0028, 0x0011 );
 
     storeTagValueRangeToProperty( sliceLocation, 0x0020, 0x1041 );
     storeTagValueRangeToProperty( acquisitionNumber, 0x0020, 0x0012 );
     storeTagValueRangeToProperty( instanceNumber, 0x0020, 0x0013 );
     storeTagValueRangeToProperty( imagePositionPatient, 0x0020, 0x0032 );
 
     storeTagValueToProperty( windowCenter, 0x0028, 0x1050 );
     storeTagValueToProperty( windowWidth, 0x0028, 0x1051 );
     storeTagValueToProperty( imageType, 0x0008, 0x0008 );
     storeTagValueToProperty( photometricInterpretation, 0x0028, 0x0004 );
 
     // some per-image attributes
     // frames are just numbered starting from 0. timestep 1 (the second time-step) has frames starting at
     // (number-of-frames-per-timestep)
     //     std::string propertyKeySliceLocation = "dicom.image.0020.1041";
     //     std::string propertyKeyInstanceNumber = "dicom.image.0020.0013";
     //     std::string propertyKeySOPInstanceNumber = "dicom.image.0008.0018";
 
     StringLookupTable sliceLocationForSlices;
     StringLookupTable instanceNumberForSlices;
     StringLookupTable SOPInstanceUIDForSlices;
     StringLookupTable filenamesForSlices_deprecated;
     DICOMCachedValueLookupTable filenamesForSlices;
 
     const DICOMTag tagSliceLocation( 0x0020, 0x1041 );
     const DICOMTag tagInstanceNumber( 0x0020, 0x0013 );
     const DICOMTag tagSOPInstanceNumber( 0x0008, 0x0018 );
 
     std::unordered_map<std::string, DICOMCachedValueLookupTable> additionalTagResultList;
 
     unsigned int slice(0);
     int timePoint(-1);
     const int framesPerTimeStep = this->GetNumberOfFramesPerTimeStep();
     for ( auto frameIter = m_ImageFrameList.begin(); frameIter != m_ImageFrameList.end();
           ++slice, ++frameIter )
     {
       unsigned int zSlice = slice%framesPerTimeStep;
       if ( zSlice == 0)
       {
         timePoint++;
       }
 
       const std::string sliceLocation = tagCache->GetTagValue( *frameIter, tagSliceLocation ).value;
       sliceLocationForSlices.SetTableValue( slice, sliceLocation );
 
       const std::string instanceNumber = tagCache->GetTagValue( *frameIter, tagInstanceNumber ).value;
       instanceNumberForSlices.SetTableValue( slice, instanceNumber );
 
       const std::string sopInstanceUID = tagCache->GetTagValue( *frameIter, tagSOPInstanceNumber ).value;
       SOPInstanceUIDForSlices.SetTableValue( slice, sopInstanceUID );
 
       const std::string filename = ( *frameIter )->Filename;
       filenamesForSlices_deprecated.SetTableValue( slice, filename );
       filenamesForSlices.SetTableValue(slice, { static_cast<unsigned int>(timePoint), zSlice, filename });
 
       MITK_DEBUG << "Tag info for slice " << slice << ": SL '" << sliceLocation << "' IN '" << instanceNumber
                  << "' SOP instance UID '" << sopInstanceUID << "'";
 
       for (const auto& tag : m_AdditionalTagMap)
       {
         const DICOMTagCache::FindingsListType findings = tagCache->GetTagValue( *frameIter, tag.first );
         for (const auto& finding : findings)
         {
           if (finding.isValid)
           {
             std::string propKey = (tag.second.empty()) ? DICOMTagPathToPropertyName(finding.path) : tag.second;
           DICOMCachedValueInfo info{ static_cast<unsigned int>(timePoint), zSlice, finding.value };
             additionalTagResultList[propKey].SetTableValue(slice, info);
           }
         }
       }
     }
 
     // add property or properties with proper names
     auto* thisInstance = const_cast<DICOMImageBlockDescriptor*>( this );
     thisInstance->SetProperty( "sliceLocationForSlices",
                                StringLookupTableProperty::New( sliceLocationForSlices ) );
 
     thisInstance->SetProperty( "instanceNumberForSlices",
                                StringLookupTableProperty::New( instanceNumberForSlices ) );
 
     thisInstance->SetProperty( "SOPInstanceUIDForSlices",
                                StringLookupTableProperty::New( SOPInstanceUIDForSlices ) );
 
     thisInstance->SetProperty( "filenamesForSlices_deprecated", StringLookupTableProperty::New( filenamesForSlices_deprecated ) );
     thisInstance->SetProperty("filenamesForSlices", m_PropertyFunctor(filenamesForSlices));
 
     //add properties for additional tags of interest
 
     for ( auto iter = additionalTagResultList.cbegin(); iter != additionalTagResultList.cend(); ++iter )
     {
       thisInstance->SetProperty( iter->first, m_PropertyFunctor( iter->second ) );
       thisInstance->m_FoundAdditionalTags.insert(m_FoundAdditionalTags.cend(),iter->first);
     }
 
     m_PropertiesOutOfDate = false;
   }
 }
 
 
 mitk::BaseProperty::Pointer
 mitk::DICOMImageBlockDescriptor::GetPropertyForDICOMValues(const DICOMCachedValueLookupTable& cacheLookupTable)
 {
   const auto& lookupTable = cacheLookupTable.GetLookupTable();
   typedef std::pair<int, DICOMCachedValueInfo> PairType;
   if ( std::adjacent_find(
          lookupTable.cbegin(),
          lookupTable.cend(),
          []( const PairType& lhs, const PairType& rhs ) { return lhs.second.Value != rhs.second.Value; } )
        == lookupTable.cend() )
   {
     return static_cast<mitk::BaseProperty::Pointer>(
       mitk::StringProperty::New(cacheLookupTable.GetTableValue(0).Value).GetPointer());
   }
 
   StringLookupTable stringTable;
   for (const auto &element : lookupTable)
   {
     stringTable.SetTableValue(element.first, element.second.Value);
   }
 
   return static_cast<mitk::BaseProperty::Pointer>(
     mitk::StringLookupTableProperty::New(stringTable).GetPointer());
 }
 
 
 void mitk::DICOMImageBlockDescriptor::SetTagLookupTableToPropertyFunctor( TagLookupTableToPropertyFunctor functor )
 {
   if ( functor != nullptr )
   {
     m_PropertyFunctor = functor;
   }
 }
 
 mitk::BaseProperty::ConstPointer mitk::DICOMImageBlockDescriptor::GetConstProperty(const std::string &propertyKey,
   const std::string &/*contextName*/,  bool /*fallBackOnDefaultContext*/) const
 {
   this->UpdateImageDescribingProperties();
   return m_PropertyList->GetConstProperty(propertyKey);
 };
 
 std::vector<std::string> mitk::DICOMImageBlockDescriptor::GetPropertyKeys(const std::string &/*contextName*/,  bool /*includeDefaultContext*/) const
 {
   this->UpdateImageDescribingProperties();
   return m_PropertyList->GetPropertyKeys();
 };
 
 std::vector<std::string> mitk::DICOMImageBlockDescriptor::GetPropertyContextNames() const
 {
   return std::vector<std::string>();
 };
diff --git a/Modules/DICOMUI/include/QmitkDicomExternalDataWidget.h b/Modules/DICOMUI/include/QmitkDicomExternalDataWidget.h
index 588628e1a4..afc501c30c 100644
--- a/Modules/DICOMUI/include/QmitkDicomExternalDataWidget.h
+++ b/Modules/DICOMUI/include/QmitkDicomExternalDataWidget.h
@@ -1,120 +1,119 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkDicomExternalDataWidget_h
 #define QmitkDicomExternalDataWidget_h
 
 #include "ui_QmitkDicomExternalDataWidgetControls.h"
 #include <MitkDICOMUIExports.h>
 
 // include ctk
 #include <ctkDICOMDatabase.h>
 #include <ctkDICOMIndexer.h>
 
 // include QT
 #include <QHash>
 #include <QLabel>
 #include <QProgressDialog>
 #include <QString>
 #include <QStringList>
 #include <QVariant>
 #include <QWidget>
 
 class ctkFileDialog;
 
 /**
 * \brief QmitkDicomExternalDataWidget is a QWidget providing functionality for dicom import.
 *
-* \sa QmitkFunctionality
 * \ingroup Functionalities
 */
 class MITKDICOMUI_EXPORT QmitkDicomExternalDataWidget : public QWidget
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
   static const std::string Widget_ID;
 
   /**
   * \brief QmitkDicomExternalDataWidget(QWidget *parent) constructor.
   *
   * \param parent is a pointer to the parent widget
   */
   QmitkDicomExternalDataWidget(QWidget *parent);
 
   /**
   * \brief QmitkDicomExternalDataWidget destructor.
   */
   ~QmitkDicomExternalDataWidget() override;
 
   /**
   * \brief CreateQtPartControl(QWidget *parent) sets the view objects from ui_QmitkDicomExternalDataWidgetControls.h.
   *
   * \param parent is a pointer to the parent widget
   */
   virtual void CreateQtPartControl(QWidget *parent);
 
   /**
   * \brief Initializes the widget. This method has to be called before widget can start.
   */
   void Initialize();
 
 signals:
 
   /// @brief emitted when import into database is finished.
   void SignalStartDicomImport(const QStringList &);
 
   /// @brief emitted when view button is clicked.
   void SignalDicomToDataManager(QHash<QString, QVariant>);
 
 public slots:
 
   /// @brief Called when download button was clicked.
   void OnDownloadButtonClicked();
 
   /// @brief Called when view button was clicked.
   void OnViewButtonClicked();
 
   /// @brief   Called when adding a dicom directory. Starts a thread adding the directory.
   void OnStartDicomImport(const QString &);
 
   void OnSeriesSelectionChanged(const QStringList &s);
 
 protected slots:
   void OnProgressStep(const QString&);
 
   void OnProgressDetail(const QString&);
 
 protected:
   /// \brief Get the list of filepath from current selected index in TreeView. All file paths referring to the index
   /// will be returned.
   QStringList GetFileNamesFromIndex();
 
   /// \brief SetupImportDialog Sets up import dialog.
   void SetupImportDialog();
 
   void SetupProgressDialog();
 
   ctkDICOMDatabase *m_ExternalDatabase;
   ctkDICOMIndexer *m_ExternalIndexer;
   ctkFileDialog *m_ImportDialog;
 
   QProgressDialog *m_ProgressDialog;
   QString m_LastImportDirectory;
   QString m_ProgressStep;
 
   Ui::QmitkDicomExternalDataWidgetControls *m_Controls;
 };
 
 #endif // _QmitkDicomExternalDataWidget_H_INCLUDED
diff --git a/Modules/DICOMUI/include/QmitkDicomLocalStorageWidget.h b/Modules/DICOMUI/include/QmitkDicomLocalStorageWidget.h
index 86d2cedc3e..b5da4acd91 100644
--- a/Modules/DICOMUI/include/QmitkDicomLocalStorageWidget.h
+++ b/Modules/DICOMUI/include/QmitkDicomLocalStorageWidget.h
@@ -1,117 +1,115 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #ifndef QmitkDicomLocalStorageWidget_h
 #define QmitkDicomLocalStorageWidget_h
 
-// #include <QmitkFunctionality.h>
 #include "ui_QmitkDicomLocalStorageWidgetControls.h"
 #include <MitkDICOMUIExports.h>
 
 // include ctk
 #include <ctkDICOMDatabase.h>
 #include <ctkDICOMIndexer.h>
 #include <ctkFileDialog.h>
 
 // include QT
 #include <QHash>
 #include <QString>
 #include <QStringList>
 #include <QVariant>
 #include <QWidget>
 
 class QProgressDialog;
 class QLabel;
 
 /**
 * \brief QmitkDicomLocalStorageWidget is a QWidget providing functionality for dicom storage and import.
 *
-* \sa QmitkFunctionality
 * \ingroup Functionalities
 */
 class MITKDICOMUI_EXPORT QmitkDicomLocalStorageWidget : public QWidget
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
   static const std::string Widget_ID;
 
   /**
    * \brief QmitkDicomLocalStorageWidget(QWidget *parent) constructor.
    *
    * \param parent is a pointer to the parent widget
    */
   QmitkDicomLocalStorageWidget(QWidget *parent);
 
   /**
    * \brief QmitkDicomExternalDataWidget destructor.
    */
   ~QmitkDicomLocalStorageWidget() override;
 
   /**
    * \brief CreateQtPartControl(QWidget *parent) sets the view objects from ui_QmitkDicomExternalDataWidgetControls.h.
    *
    * \param parent is a pointer to the parent widget
    */
   virtual void CreateQtPartControl(QWidget *parent);
 
   /**
    * \brief SetDatabaseDirectory sets database directory.
    *
    * \param newDatabaseDirectory contains path to new database directoy.
    */
   void SetDatabaseDirectory(QString newDatabaseDirectory);
 
 signals:
 
   /// @brief emitted when import into database is finished.
   void SignalFinishedImport();
 
   /**
    * @brief emitted when view button is clicked.
    * @param _t1 containing dicom UIDs properties.
    */
   void SignalDicomToDataManager(QHash<QString, QVariant> _t1);
 
   /// \brief emitted if cancel button is pressed.
   void SignalCancelImport();
 
 public slots:
   /// @brief Called when view button was clicked.
   void OnViewButtonClicked();
 
   /// @brief   Called delete button was clicked.
   void OnDeleteButtonClicked();
 
   /// @brief   Called when adding a dicom directory. Starts a thread adding the directory.
   void OnStartDicomImport(const QString &dicomData);
 
   /// @brief   Called when adding a list of dicom files. Starts a thread adding the dicom files.
   void OnStartDicomImport(const QStringList &dicomData);
 
   /// @brief Called when the selection in the series table has changed
   void OnSeriesSelectionChanged(const QStringList &);
 
 protected:
   void SetDatabase(QString databaseFile);
 
   bool DeletePatients();
   bool DeleteStudies();
   bool DeleteSeries();
 
   ctkDICOMDatabase *m_LocalDatabase;
   ctkDICOMIndexer *m_LocalIndexer;
   Ui::QmitkDicomLocalStorageWidgetControls *m_Controls;
 };
 
 #endif // _QmitkDicomLocalStorageWidget_H_INCLUDED
diff --git a/Modules/IGT/Rendering/mitkNavigationDataSliceVisualization.cpp b/Modules/IGT/Rendering/mitkNavigationDataSliceVisualization.cpp
index 0f1161ce22..afa4447a0b 100644
--- a/Modules/IGT/Rendering/mitkNavigationDataSliceVisualization.cpp
+++ b/Modules/IGT/Rendering/mitkNavigationDataSliceVisualization.cpp
@@ -1,219 +1,219 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #include "mitkNavigationDataSliceVisualization.h"
 
 #include "mitkBaseRenderer.h"
 
 mitk::NavigationDataSliceVisualization::NavigationDataSliceVisualization() : mitk::NavigationDataToNavigationDataFilter(),
   m_Renderer(nullptr),
   m_ViewDirection(Axial)
 {
   m_TipOffset[0] = 0.0f;
   m_TipOffset[1] = 0.0f;
   m_TipOffset[2] = 0.0f;
 
   m_ToolTrajectory[0] = 0;
   m_ToolTrajectory[1] = 0;
   m_ToolTrajectory[2] = -1;
 
   m_WorldVerticalVector[0] = 0.0;
   m_WorldVerticalVector[1] = 1.0;
   m_WorldVerticalVector[2] = 0.0;
 }
 
 void mitk::NavigationDataSliceVisualization::SetToolTrajectory(Vector3D direction)
 {
   if (Equal(direction.GetNorm(), 0.0))
   {
     MITK_WARN << "Ignoring invalid direction of projection: " << direction;
     return;
   }
 
   if (m_ToolTrajectory != direction)
   {
     m_ToolTrajectory = direction;
     this->SetViewDirection(Oblique);
     this->Modified();
   }
 }
 
 void mitk::NavigationDataSliceVisualization::GenerateData()
 {
   // check if renderer was set
   if (m_Renderer.IsNull())
   {
     itkExceptionMacro(<< "Renderer was not properly set");
   }
 
   /* update outputs with tracking data from tools */
   unsigned int numberOfInputs = this->GetNumberOfInputs();
   if (numberOfInputs == 0)
   {
     return;
   }
   for (unsigned int i = 0; i < numberOfInputs ; ++i)
   {
     NavigationData* output = this->GetOutput(i);
     assert(output);
     const NavigationData* input = this->GetInput(i);
     assert(input);
 
     if (!input->IsDataValid())
       continue;
 
     output->Graft(input); // First, copy all information from input to output
   }
 
   // Nothing left to do if we don't have an input with valid data
   if (numberOfInputs == 0 || !this->GetInput()->IsDataValid())
     return;
 
   // get position from NavigationData to move the slice to this position
   Point3D slicePosition = this->GetInput()->GetPosition();
 
   {
     NavigationData::OrientationType orientation = this->GetInput()->GetOrientation();
 
     Vector3D transformedTipOffset;
     transformedTipOffset.SetVnlVector(orientation.rotate(m_TipOffset.GetVnlVector()).as_ref());
 
     slicePosition += transformedTipOffset;
 
     mitk::SliceNavigationController::Pointer snc = m_Renderer->GetSliceNavigationController();
 
     if (Axial == m_ViewDirection)
     {
       snc->SetViewDirection(mitk::SliceNavigationController::Axial);
       snc->SelectSliceByPoint(slicePosition);
     }
     else if (Sagittal == m_ViewDirection)
     {
       snc->SetViewDirection(mitk::SliceNavigationController::Sagittal);
       snc->SelectSliceByPoint(slicePosition);
     }
-    else if (Frontal == m_ViewDirection)
+    else if (Coronal == m_ViewDirection)
     {
-      snc->SetViewDirection(mitk::SliceNavigationController::Frontal);
+      snc->SetViewDirection(mitk::SliceNavigationController::Coronal);
       snc->SelectSliceByPoint(slicePosition);
     }
     else if (AxialOblique == m_ViewDirection || SagittalOblique == m_ViewDirection)
     {
       const int slicingPlaneXAxis = AxialOblique == m_ViewDirection ? 0 : 2;
 
       // The column 0 is the slicing plane's x-axis, column 1 is the slicing plane's y-axis
       const mitk::PlaneGeometry::TransformType::MatrixType &m =
             m_Renderer->GetCurrentWorldPlaneGeometry()->GetIndexToWorldTransform()->GetMatrix();
 
       // Rotate the tool trajectory vector into world coordinate frame (assuming
       // NavigationData has passed through a NavigationDataTransformFilter to
       // convert it into world coordinate frame)
       Vector3D slicingPlaneYAxisVector;
       slicingPlaneYAxisVector.SetVnlVector(orientation.rotate(m_ToolTrajectory.GetVnlVector()).as_ref());
 
       // Project the tool trajectory onto the plane normal to x-axis of this
       // oblique slicing. This defines the y-axis ("up") of the oblique slicing
       // plane
       slicingPlaneYAxisVector[slicingPlaneXAxis] = 0.0;
 
       // Do nothing for ambigous/undefined cases:
       //   - the R-L component of the x-axis is zero (for AxialOblique)
       //   - the S-I component of the x-axis is zero (for SagittalOblique)
       //   - the A-P component of the y-axis is zero
       if ( m(slicingPlaneXAxis,0) == 0.0 ||
            m(1,1) == 0.0 ||
            (slicingPlaneXAxis != 0 && slicingPlaneYAxisVector[0] == 0.0) ||
            (slicingPlaneXAxis != 1 && slicingPlaneYAxisVector[1] == 0.0) ||
            (slicingPlaneXAxis != 2 && slicingPlaneYAxisVector[2] == 0.0) )
       {
         return;
       }
 
       // Maintain the A-P orientation of the slice's y-axis regardless of what
       // direction the tool trajectory points
       /// @todo<C++11> Use std::signbit
       if ( (m(1,1) > 0) != (slicingPlaneYAxisVector[1] > 0) )
       {
         slicingPlaneYAxisVector *= -1;
       }
 
       Vector3D slicingPlaneXAxisVector;
       slicingPlaneXAxisVector.Fill(0.0);
       // For AxialOblique: maintain the Left/Right direction of the slice's x-axis
       // For SagittalOblique: maintain the Superior/Inferior direction of the slice's x-axis
       /// @todo<C++11> Use std::copysign
       slicingPlaneXAxisVector[slicingPlaneXAxis] = m(slicingPlaneXAxis,0) > 0 ? 1.0 : -1.0;
 
       Point3D origin;
       FillVector3D(origin, 0.0, 0.0, 0.0);
       snc->ReorientSlices(origin, slicingPlaneXAxisVector, slicingPlaneYAxisVector);
       snc->SelectSliceByPoint(slicePosition);
     }
     else if (Oblique == m_ViewDirection)
     {
       Vector3D slicingPlaneNormalVector;
       slicingPlaneNormalVector.SetVnlVector(orientation.rotate(m_ToolTrajectory.GetVnlVector()).as_ref());
 
       // The second column of the Index-to-World matrix is the positive y-axis
       // of the current slicing plane in world coordinates.
       const mitk::PlaneGeometry::TransformType::MatrixType &m =
             m_Renderer->GetCurrentWorldPlaneGeometry()->GetIndexToWorldTransform()->GetMatrix();
       mitk::Vector3D currentSlicingPlaneUpVector;
       mitk::FillVector3D(currentSlicingPlaneUpVector, m[0][1], m[1][1], m[2][1]);
       mitk::Vector3D worldUpVector = m_WorldVerticalVector;
       if (angle(worldUpVector.GetVnlVector(), currentSlicingPlaneUpVector.GetVnlVector()) > vnl_math::pi_over_2 )
       {
         worldUpVector *= -1;
       }
 
       mitk::PlaneGeometry::Pointer slicingPlane = mitk::PlaneGeometry::New();
       Point3D origin;
       FillVector3D(origin, 0.0, 0.0, 0.0);
       slicingPlane->InitializePlane(origin, slicingPlaneNormalVector);
 
       // Now that we have the direction of WorldVerticalVector chosen to be the
       // most "up" direction, project it onto the slicing plane to define the
       // up vector (y-axis) of the reoriented slices
       mitk::Vector3D slicingPlaneUpVector;
       if ( slicingPlane->Project(worldUpVector, slicingPlaneUpVector) )
       {
         // slicingPlaneUpVector CROSS slicingPlaneNormalVector -> slicingPlaneRightVector
         // Math is done in double precision as much as possible to get more
         // orthogonal right and up vectors which fixes a VNL SVD error when
         // the WorldGeometry matrix is later inverted
         itk::Vector<double,3> slicingPlaneUpVector_double;
         FillVector3D(slicingPlaneUpVector_double,
                      slicingPlaneUpVector[0], slicingPlaneUpVector[1], slicingPlaneUpVector[2]);
         itk::Vector<double,3> slicingPlaneNormalVector_double;
         FillVector3D(slicingPlaneNormalVector_double,
                      slicingPlaneNormalVector[0], slicingPlaneNormalVector[1], slicingPlaneNormalVector[2]);
         itk::Vector<double,3> slicingPlaneRightVector_double = itk::CrossProduct(slicingPlaneUpVector_double,
                                                                                  slicingPlaneNormalVector_double);
 
         mitk::Vector3D slicingPlaneRightVector;
         mitk::FillVector3D(slicingPlaneRightVector,
                            slicingPlaneRightVector_double[0], slicingPlaneRightVector_double[1], slicingPlaneRightVector_double[2]);
         mitk::FillVector3D(slicingPlaneUpVector,
                            slicingPlaneUpVector_double[0], slicingPlaneUpVector_double[1], slicingPlaneUpVector_double[2]);
 
         snc->ReorientSlices(origin, slicingPlaneRightVector, slicingPlaneUpVector);
         snc->SelectSliceByPoint(slicePosition);
       }
     }
     else
     {
       MITK_ERROR << "Unsupported ViewDirection: " << m_ViewDirection;
     }
 
     m_Renderer->RequestUpdate();
   }
 }
 
diff --git a/Modules/IGT/Rendering/mitkNavigationDataSliceVisualization.h b/Modules/IGT/Rendering/mitkNavigationDataSliceVisualization.h
index 179edc46f7..a78f7e1cf6 100644
--- a/Modules/IGT/Rendering/mitkNavigationDataSliceVisualization.h
+++ b/Modules/IGT/Rendering/mitkNavigationDataSliceVisualization.h
@@ -1,135 +1,135 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #ifndef MITKNAVIGATIONDATASLICEVISUALIZATION_H_HEADER_INCLUDED_
 #define MITKNAVIGATIONDATASLICEVISUALIZATION_H_HEADER_INCLUDED_
 
 #include "mitkNavigationDataToNavigationDataFilter.h"
 #include "mitkBaseRenderer.h"
 #include "mitkVector.h"
 
 namespace mitk
 {
 /**Documentation
 * \brief Control the position and orientation of rendered slices with NavigationData
 *
 * A NavigationDataToNavigationDataFilter that takes NavigationData as input and
 * sets the position and, optionally, the orientation of the slice plane for a
 * user-specified renderer.
 *
 * \ingroup IGT
 */
 class MITKIGT_EXPORT NavigationDataSliceVisualization : public NavigationDataToNavigationDataFilter
 {
   public:
     mitkClassMacro(NavigationDataSliceVisualization, NavigationDataToNavigationDataFilter);
     itkNewMacro(Self);
 
     enum ViewDirection
     {
       /**
        * Tracked slice planes are NOT re-oriented, only the position
        * of the slice plane is controlled by the input navigation data.
        */
       Axial = 0,
       Sagittal,
-      Frontal,
+      Coronal,
       /**
        * Axial plane "tilted" about the lateral vector so that it is coplanar
        * with the tool trajectory
        */
       AxialOblique,
       /**
        * Sagittal plane "tilted" about the axial vector so that it is coplanar
        * with the tool trajectory
        */
       SagittalOblique,
       /**
        * Slice plane normal to the tool trajectory
        */
       Oblique
     };
 
     /**
      * \brief Set/get the renderer that visualizes the navigation data
      */
     itkSetObjectMacro(Renderer,BaseRenderer);
     itkGetConstObjectMacro(Renderer,BaseRenderer);
 
     /**
      * \brief Set/get the tip offset used for plane tracking
      *
      * This is an additional offset vector applied to the input navigation
      * data. It is defined in tool tip coordinates. In other words:
      *
      * \code
      * position_slice = position_input + orient_input.rotate(TipOffset)
      * \endcode
      *
      * Default is [0,0,0].
      */
     itkSetMacro(TipOffset, Vector3D);
     itkGetConstMacro(TipOffset,Vector3D);
 
     /**
      * \brief Set/get the tool trajectory used to define the cutting plane
      * normal direction.
      *
      * This vector, defined in tool tip coordinates, applies only when the
      * ViewDirection is Oblique.
      *
      * Default is [0,0,-1].
      */
     virtual void SetToolTrajectory(Vector3D direction);
     itkGetConstMacro(ToolTrajectory, Vector3D);
 
     /**
      * \brief Set/get the world vertical vector used to define the y-axis of the
      * cutting plane
      *
      * This vector, defined in world coordinates, applies only when the
      * ViewDirection is Oblique. It is projected onto the cutting plane to
      * define the vertical orientation of the slice.
      *
      * The direction of this vector does not matter (i.e. [0,1,0] is the same
      * as [0,-1,0]). The direction will be determined automatically by
      * choosing the one that is closest to the direction of the y-axis of the
      * PlaneGeometry before each update. This way, the anatomical axis
      * directions that get set initially will be maintained after every update
      * of this filter.
      *
      * Default is [0,1,0].
      */
     itkSetMacro(WorldVerticalVector, Vector3D);
     itkGetConstMacro(WorldVerticalVector, Vector3D);
 
     /**
      * \brief Set/get the orientation of the sliced plane
      *
      * Default is Axial.
      */
     itkSetEnumMacro(ViewDirection,ViewDirection);
     itkGetEnumMacro(ViewDirection,ViewDirection);
 
   protected:
     NavigationDataSliceVisualization();
     void GenerateData() override;
 
     BaseRenderer::Pointer m_Renderer;
     Vector3D m_TipOffset;
     Vector3D m_ToolTrajectory;
     Vector3D m_WorldVerticalVector;
     ViewDirection m_ViewDirection;
 };
 
 } // end namespace mitk
 
 #endif // NEMOSLICEVISUALIZATIONFILTER_H
diff --git a/Modules/IGTBase/autoload/IO/mitkNavigationDataSetWriterXML.cpp b/Modules/IGTBase/autoload/IO/mitkNavigationDataSetWriterXML.cpp
index 1256f4f8f0..c39e49d5c1 100644
--- a/Modules/IGTBase/autoload/IO/mitkNavigationDataSetWriterXML.cpp
+++ b/Modules/IGTBase/autoload/IO/mitkNavigationDataSetWriterXML.cpp
@@ -1,141 +1,143 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // MITK
 #include "mitkNavigationDataSetWriterXML.h"
 #include <mitkIGTMimeTypes.h>
 #include <mitkLocaleSwitch.h>
 
 // Third Party
 #include <tinyxml2.h>
 #include <itksys/SystemTools.hxx>
 #include <fstream>
 #include <iostream>
 
 mitk::NavigationDataSetWriterXML::NavigationDataSetWriterXML() : AbstractFileWriter(NavigationDataSet::GetStaticNameOfClass(),
   mitk::IGTMimeTypes::NAVIGATIONDATASETXML_MIMETYPE(),
   "MITK NavigationDataSet Writer (XML)")
 {
   RegisterService();
 }
 
 mitk::NavigationDataSetWriterXML::NavigationDataSetWriterXML(const mitk::NavigationDataSetWriterXML& other) : AbstractFileWriter(other)
 {
 }
 
 mitk::NavigationDataSetWriterXML::~NavigationDataSetWriterXML()
 {
 }
 
 mitk::NavigationDataSetWriterXML* mitk::NavigationDataSetWriterXML::Clone() const
 {
   return new NavigationDataSetWriterXML(*this);
 }
 
 void mitk::NavigationDataSetWriterXML::Write()
 {
   std::ostream* out = GetOutputStream();
   if (out == nullptr)
   {
     out = new std::ofstream( GetOutputLocation().c_str() );
   }
   mitk::NavigationDataSet::ConstPointer data = dynamic_cast<const NavigationDataSet*> (this->GetInput());
 
   mitk::LocaleSwitch localeSwitch("C");
 
   StreamHeader(out, data);
   StreamData(out, data);
   StreamFooter(out);
 
   // Cleanup
   out->flush();
   delete out;
 }
 
 void mitk::NavigationDataSetWriterXML::StreamHeader (std::ostream* stream, mitk::NavigationDataSet::ConstPointer data)
 {
   stream->precision(10);
 
   //TODO store date and GMT time
   //checking if the stream is good
   if (stream->good())
   {
     *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" << std::endl;
     /**m_Stream << "<Version Ver=\"1\" />" << std::endl;*/
     // should be a generic version, meaning a member variable, which has the actual version
     *stream << "    " << "<Data ToolCount=\"" << data->GetNumberOfTools() << "\" version=\"1.0\">" << std::endl;
   }
 }
 
 void mitk::NavigationDataSetWriterXML::StreamData (std::ostream* stream, mitk::NavigationDataSet::ConstPointer data)
 {
   // For each time step in the Dataset
   for (auto it = data->Begin(); it != data->End(); it++)
   {
     for (std::size_t toolIndex = 0; toolIndex < it->size(); toolIndex++)
     {
       mitk::NavigationData::Pointer nd = it->at(toolIndex);
       tinyxml2::XMLDocument doc;
       auto *elem = doc.NewElement("ND");
 
       elem->SetAttribute("Time", nd->GetIGTTimeStamp());
       // elem->SetAttribute("SystemTime", sysTimeStr); // tag for system time
       elem->SetAttribute("Tool", static_cast<int>(toolIndex));
       elem->SetAttribute("X", nd->GetPosition()[0]);
       elem->SetAttribute("Y", nd->GetPosition()[1]);
       elem->SetAttribute("Z", nd->GetPosition()[2]);
 
       elem->SetAttribute("QX", nd->GetOrientation()[0]);
       elem->SetAttribute("QY", nd->GetOrientation()[1]);
       elem->SetAttribute("QZ", nd->GetOrientation()[2]);
       elem->SetAttribute("QR", nd->GetOrientation()[3]);
 
       elem->SetAttribute("C00", nd->GetCovErrorMatrix()[0][0]);
       elem->SetAttribute("C01", nd->GetCovErrorMatrix()[0][1]);
       elem->SetAttribute("C02", nd->GetCovErrorMatrix()[0][2]);
       elem->SetAttribute("C03", nd->GetCovErrorMatrix()[0][3]);
       elem->SetAttribute("C04", nd->GetCovErrorMatrix()[0][4]);
       elem->SetAttribute("C05", nd->GetCovErrorMatrix()[0][5]);
       elem->SetAttribute("C10", nd->GetCovErrorMatrix()[1][0]);
       elem->SetAttribute("C11", nd->GetCovErrorMatrix()[1][1]);
       elem->SetAttribute("C12", nd->GetCovErrorMatrix()[1][2]);
       elem->SetAttribute("C13", nd->GetCovErrorMatrix()[1][3]);
       elem->SetAttribute("C14", nd->GetCovErrorMatrix()[1][4]);
       elem->SetAttribute("C15", nd->GetCovErrorMatrix()[1][5]);
 
       if (nd->IsDataValid())
         elem->SetAttribute("Valid",1);
       else
         elem->SetAttribute("Valid",0);
 
       if (nd->GetHasOrientation())
         elem->SetAttribute("hO",1);
       else
         elem->SetAttribute("hO",0);
 
       if (nd->GetHasPosition())
         elem->SetAttribute("hP",1);
       else
         elem->SetAttribute("hP",0);
 
+      doc.InsertFirstChild(elem);
+
       tinyxml2::XMLPrinter printer;
       doc.Print(&printer);
 
       *stream << "        " << printer.CStr() << std::endl;
     }
   }
 }
 
 void mitk::NavigationDataSetWriterXML::StreamFooter (std::ostream* stream)
 {
   *stream << "</Data>" << std::endl;
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.cpp
index ee1b33b256..7858243380 100644
--- a/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.cpp
@@ -1,421 +1,421 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkFiducialRegistrationWidget.h"
 
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkAppendPolyData.h>
 #include <vtkPoints.h>
 #include <vtkLandmarkTransform.h>
 #include <mitkStaticIGTHelperFunctions.h>
 
 #include <mitkRenderingManager.h>
 
 #define FRW_LOG MITK_INFO("Fiducial Registration Widget")
 #define FRW_WARN MITK_WARN("Fiducial Registration Widget")
 #define FRW_DEBUG MITK_DEBUG("Fiducial Registration Widget")
 
 /* VIEW MANAGEMENT */
 QmitkFiducialRegistrationWidget::QmitkFiducialRegistrationWidget(QWidget* parent)
 : QWidget(parent), m_Controls(nullptr),m_MultiWidget(nullptr), m_ImageFiducialsNode(nullptr), m_TrackerFiducialsNode(nullptr)
 {
   CreateQtPartControl(this);
 }
 
 
 QmitkFiducialRegistrationWidget::~QmitkFiducialRegistrationWidget()
 {
   m_Controls = nullptr;
 
   //clean up data nodes
   if (m_DataStorage.IsNotNull())
   {
     if (m_ImageFiducialsNode.IsNotNull()) m_DataStorage->Remove(m_ImageFiducialsNode);
     if (m_TrackerFiducialsNode.IsNotNull()) m_DataStorage->Remove(m_TrackerFiducialsNode);
   }
 }
 
 
 void QmitkFiducialRegistrationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkFiducialRegistrationWidget;
     m_Controls->setupUi(parent);
 
     // hide additional image fiducial button
     m_Controls->m_AddImageFiducialBtn->setHidden(true);
 
     m_Controls->m_spaceHolderGroupBox->setStyleSheet("QGroupBox {border: 0px transparent;}");
     m_Controls->m_spaceHolderGroupBox2->setStyleSheet("QGroupBox {border: 0px transparent;}");
 
     this->CreateConnections();
   }
 }
 
 
 void QmitkFiducialRegistrationWidget::CreateConnections()
 {
   connect( (QObject*)(m_Controls->m_AddTrackingFiducialBtn), SIGNAL(clicked()), this, SIGNAL(AddedTrackingFiducial()) );
   connect((QObject*)(m_Controls->m_AddTrackingFiducialBtn), SIGNAL(clicked()), this, SLOT(AddTrackerPoint()));
   connect( (QObject*)(m_Controls->m_AddImageFiducialBtn), SIGNAL(clicked()), this, SIGNAL(AddedImageFiducial()) );
   connect( (QObject*)(m_Controls->m_RegisterFiducialsBtn), SIGNAL(clicked()), this, SIGNAL(PerformFiducialRegistration()) );
   connect((QObject*)(m_Controls->m_RegisterFiducialsBtn), SIGNAL(clicked()), this, SLOT(Register()));
   connect( (QObject*)(m_Controls->m_UseICPRegistration), SIGNAL(toggled(bool)), this, SIGNAL(FindFiducialCorrespondences(bool)) );
 
   //unselects the edit button of the other widget if one is selected
   connect( (QObject*)(m_Controls->m_RegistrationImagePoints), SIGNAL(EditPointSets(bool)), this, SLOT(DisableEditButtonRegistrationTrackingPoints(bool)));
   connect( (QObject*)(m_Controls->m_RegistrationTrackingPoints), SIGNAL(EditPointSets(bool)), this, SLOT(DisableEditButtonRegistrationImagePoints(bool)));
 }
 
 void QmitkFiducialRegistrationWidget::DisableEditButtonRegistrationImagePoints(bool activated)
 {
 if (activated) m_Controls->m_RegistrationImagePoints->UnselectEditButton();
 }
 void QmitkFiducialRegistrationWidget::DisableEditButtonRegistrationTrackingPoints(bool activated)
 {
 if (activated) m_Controls->m_RegistrationTrackingPoints->UnselectEditButton();
 }
 
 void QmitkFiducialRegistrationWidget::SetWidgetAppearanceMode(WidgetAppearanceMode widgetMode)
 {
   if (widgetMode==LANDMARKMODE)
   {
     this->HideContinousRegistrationRadioButton(true);
     this->HideStaticRegistrationRadioButton(true);
     this->HideFiducialRegistrationGroupBox();
     this->HideUseICPRegistrationCheckbox(true);
     this->HideImageFiducialButton(false);
     this->m_Controls->sourceLandmarksGroupBox->setTitle("Target/Reference landmarks");
     this->m_Controls->targetLandmarksGroupBox->setTitle("Source Landmarks");
     this->m_Controls->m_AddImageFiducialBtn->setText("Add target landmark");
     this->m_Controls->m_AddTrackingFiducialBtn->setText("Add source landmark");
   }
   else if (widgetMode==FIDUCIALMODE)
   {
     this->HideContinousRegistrationRadioButton(false);
     this->HideStaticRegistrationRadioButton(false);
     this->HideFiducialRegistrationGroupBox();
     this->HideUseICPRegistrationCheckbox(false);
     this->HideImageFiducialButton(true);
     this->m_Controls->sourceLandmarksGroupBox->setTitle("Image fiducials");
     this->m_Controls->targetLandmarksGroupBox->setTitle("OR fiducials");
     this->m_Controls->m_AddImageFiducialBtn->setText("Add image fiducial");
     this->m_Controls->m_AddTrackingFiducialBtn->setText("Add current instrument position");
   }
 }
 
 void QmitkFiducialRegistrationWidget::SetQualityDisplayText( QString text )
 {
   if (text == nullptr)
     return;
   m_Controls->m_RegistrationQualityDisplay->setText(text); // set text on the QLabel
 }
 
 bool QmitkFiducialRegistrationWidget::UseICPIsChecked()
 {
   if(m_Controls->m_UseICPRegistration->isChecked())
     return true;
   else
     return false;
 }
 
 void QmitkFiducialRegistrationWidget::SetImageFiducialsNode( mitk::DataNode::Pointer imageFiducialsNode )
 {
   if(imageFiducialsNode.IsNull())
   {
     FRW_WARN<< "tracker fiducial node is nullptr";
     return;
   }
   m_Controls->m_RegistrationImagePoints->SetPointSetNode(imageFiducialsNode); // pass node to pointListWidget
   if(m_MultiWidget == nullptr)
   {
-    MITK_DEBUG<< "stdMultiWidget is nullptr";
+    MITK_DEBUG<< "MultiWidget is nullptr";
     return;
   }
   m_Controls->m_RegistrationImagePoints->SetMultiWidget(m_MultiWidget); // pass multiWidget to pointListWidget
 }
 
 void QmitkFiducialRegistrationWidget::SetTrackerFiducialsNode( mitk::DataNode::Pointer trackerFiducialsNode )
 {
   if(trackerFiducialsNode.IsNull())
   {
     FRW_WARN<< "tracker fiducial node is nullptr";
     return;
   }
   m_Controls->m_RegistrationTrackingPoints->SetPointSetNode(trackerFiducialsNode); // pass node to pointListWidget
   if(m_MultiWidget == nullptr)
   {
-    MITK_DEBUG<< "stdMultiWidget is nullptr";
+    MITK_DEBUG<< "MultiWidget is nullptr";
     return;
   }
   m_Controls->m_RegistrationTrackingPoints->SetMultiWidget(m_MultiWidget); // pass multiWidget to pointListWidget
 }
 
-void QmitkFiducialRegistrationWidget::SetMultiWidget( QmitkStdMultiWidget* multiWidget )
+void QmitkFiducialRegistrationWidget::SetMultiWidget( QmitkAbstractMultiWidget* multiWidget )
 {
   m_MultiWidget=multiWidget;
 }
 
 void QmitkFiducialRegistrationWidget::AddSliceNavigationController(mitk::SliceNavigationController* snc)
 {
   m_Controls->m_RegistrationTrackingPoints->AddSliceNavigationController(snc);
   m_Controls->m_RegistrationImagePoints->AddSliceNavigationController(snc);
 }
 
 mitk::DataNode::Pointer QmitkFiducialRegistrationWidget::GetImageFiducialsNode()
 {
   return m_ImageFiducialsNode;
 }
 
 mitk::DataNode::Pointer QmitkFiducialRegistrationWidget::GetTrackerFiducialsNode()
 {
   return m_TrackerFiducialsNode;
 }
 
 void QmitkFiducialRegistrationWidget::HideStaticRegistrationRadioButton( bool on )
 {
   m_Controls->m_rbStaticRegistration->setHidden(on);
   HideFiducialRegistrationGroupBox();
 }
 
 void QmitkFiducialRegistrationWidget::HideContinousRegistrationRadioButton( bool on )
 {
   m_Controls->m_rbContinousRegistration->setHidden(on);
   HideFiducialRegistrationGroupBox();
 }
 
 void QmitkFiducialRegistrationWidget::HideFiducialRegistrationGroupBox()
 {
   if (m_Controls->m_rbStaticRegistration->isHidden() && m_Controls->m_rbContinousRegistration->isHidden())
   {
     m_Controls->m_gbFiducialRegistration->setHidden(true);
   }
   else
   {
     m_Controls->m_gbFiducialRegistration->setHidden(false);
   }
 }
 
 void QmitkFiducialRegistrationWidget::HideUseICPRegistrationCheckbox( bool on )
 {
   m_Controls->m_UseICPRegistration->setHidden(on);
 }
 
 void QmitkFiducialRegistrationWidget::HideImageFiducialButton( bool on )
 {
   m_Controls->m_AddImageFiducialBtn->setHidden(on);
   AdjustButtonSpacing();
 
 }
 
 void QmitkFiducialRegistrationWidget::HideTrackingFiducialButton( bool on )
 {
   m_Controls->m_AddTrackingFiducialBtn->setHidden(on);
   AdjustButtonSpacing();
 }
 
 void QmitkFiducialRegistrationWidget::AdjustButtonSpacing()
 {
   if (m_Controls->m_AddImageFiducialBtn->isHidden() && m_Controls->m_AddTrackingFiducialBtn->isHidden())
   {
     m_Controls->m_spaceHolderGroupBox->setHidden(true);
     m_Controls->m_spaceHolderGroupBox2->setHidden(true);
   }
   else
   {
     m_Controls->m_spaceHolderGroupBox->setHidden(false);
     m_Controls->m_spaceHolderGroupBox2->setHidden(false);
   }
 }
 
 void QmitkFiducialRegistrationWidget::SetSourceLandmarkName(QString sourceLandmarkName)
 {
   QString groupBoxTitle = sourceLandmarkName;
   groupBoxTitle.append(" Landmarks");
   m_Controls->sourceLandmarksGroupBox->setTitle(groupBoxTitle);
   QString buttonText = "Add ";
   buttonText.append(sourceLandmarkName);
   buttonText.append(" Landmark");
   m_Controls->m_AddImageFiducialBtn->setText(buttonText);
 }
 
 void QmitkFiducialRegistrationWidget::SetTargetLandmarkName(QString targetLandmarkName)
 {
   QString groupBoxTitle = targetLandmarkName;
   groupBoxTitle.append(" Landmarks");
   m_Controls->targetLandmarksGroupBox->setTitle(groupBoxTitle);
   QString buttonText = "Add ";
   buttonText.append(targetLandmarkName);
   buttonText.append(" Landmark");
   m_Controls->m_AddTrackingFiducialBtn->setText(buttonText);
 }
 
 void QmitkFiducialRegistrationWidget::setImageNode(mitk::DataNode::Pointer i)
 {
   m_ImageNode = i;
 }
 
 void QmitkFiducialRegistrationWidget::setTrackerNavigationData(mitk::NavigationData::Pointer t)
 {
   m_TrackerNavigationData = t;
 }
 
 void QmitkFiducialRegistrationWidget::setDataStorage(mitk::DataStorage::Pointer d)
 {
   m_DataStorage = d;
 
   mitk::DataNode::Pointer ImageFiducialsNode = mitk::DataNode::New();
   mitk::PointSet::Pointer imagePointSet = mitk::PointSet::New();
   ImageFiducialsNode->SetData(imagePointSet);
   ImageFiducialsNode->SetName("Image Point Set");
   m_DataStorage->Add(ImageFiducialsNode);
   this->SetImageFiducialsNode(ImageFiducialsNode);
   m_ImageFiducialsNode = ImageFiducialsNode;
 
   mitk::DataNode::Pointer TrackerFiducialsNode = mitk::DataNode::New();
   mitk::PointSet::Pointer trackerPointSet = mitk::PointSet::New();
   TrackerFiducialsNode->SetData(trackerPointSet);
   TrackerFiducialsNode->SetName("Tracker Point Set");
   m_DataStorage->Add(TrackerFiducialsNode);
   this->SetTrackerFiducialsNode(TrackerFiducialsNode);
   m_TrackerFiducialsNode = TrackerFiducialsNode;
 }
 
 void QmitkFiducialRegistrationWidget::AddTrackerPoint()
 {
   if (m_DataStorage.IsNull()) { return ; } //here the widget should simply do nothing (for backward compatibility)
   else if (m_TrackerNavigationData.IsNull() || m_TrackerFiducialsNode.IsNull()) { MITK_WARN << "Tracker node not correctly initialized"; return; }
   mitk::PointSet::Pointer ps = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsNode->GetData());
   ps->InsertPoint(ps->GetSize(), m_TrackerNavigationData->GetPosition());
 }
 
 bool QmitkFiducialRegistrationWidget::CheckRegistrationInitialization()
 {
   if (m_DataStorage.IsNull()) { return false; } //here the widget should simply do nothing (for backward compatibility)
   else if ( m_ImageFiducialsNode.IsNull() ||
       m_TrackerFiducialsNode.IsNull()
       ) {MITK_WARN << "Registration not correctly initialized"; return false;}
   else {return true;}
 }
 
 void QmitkFiducialRegistrationWidget::Register()
 {
   //Check for initialization
   if (!CheckRegistrationInitialization()) return;
 
   /* retrieve fiducials */
   mitk::PointSet::Pointer imageFiducials = dynamic_cast<mitk::PointSet*>(m_ImageFiducialsNode->GetData());
   mitk::PointSet::Pointer trackerFiducials = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsNode->GetData());
   if (trackerFiducials->GetSize() != imageFiducials->GetSize())
   {
     MITK_WARN << "Not the same number of fiducials, cannot register";
     return;
   }
   else if (trackerFiducials->GetSize() < 3)
   {
     MITK_WARN << "Need at least 3 fiducials, cannot register";
     return;
   }
 
   //############### conversion to vtk data types (we will use the vtk landmark based transform) ##########################
   //convert point sets to vtk poly data
   vtkSmartPointer<vtkPoints> sourcePoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPoints> targetPoints = vtkSmartPointer<vtkPoints>::New();
   for (int i = 0; i<imageFiducials->GetSize(); i++)
   {
     double point[3] = { imageFiducials->GetPoint(i)[0], imageFiducials->GetPoint(i)[1], imageFiducials->GetPoint(i)[2] };
     sourcePoints->InsertNextPoint(point);
     double point_targets[3] = { trackerFiducials->GetPoint(i)[0], trackerFiducials->GetPoint(i)[1], trackerFiducials->GetPoint(i)[2] };
     targetPoints->InsertNextPoint(point_targets);
   }
 
   //########################### here, the actual transform is computed ##########################
   //compute transform
   vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
   transform->SetSourceLandmarks(sourcePoints);
   transform->SetTargetLandmarks(targetPoints);
   transform->SetModeToRigidBody();
   transform->Modified();
   transform->Update();
   //compute FRE of transform
 
   double FRE = mitk::StaticIGTHelperFunctions::ComputeFRE(imageFiducials, trackerFiducials, transform);
   this->SetQualityDisplayText("FRE: " + QString::number(FRE) + " mm");
 
   //#############################################################################################
 
   //############### conversion back to itk/mitk data types ##########################
   //convert from vtk to itk data types
   itk::Matrix<float, 3, 3> rotationFloat = itk::Matrix<float, 3, 3>();
   itk::Vector<float, 3> translationFloat = itk::Vector<float, 3>();
   itk::Matrix<double, 3, 3> rotationDouble = itk::Matrix<double, 3, 3>();
   itk::Vector<double, 3> translationDouble = itk::Vector<double, 3>();
 
   vtkSmartPointer<vtkMatrix4x4> m = transform->GetMatrix();
   for (int k = 0; k<3; k++) for (int l = 0; l<3; l++)
   {
     rotationFloat[k][l] = m->GetElement(k, l);
     rotationDouble[k][l] = m->GetElement(k, l);
 
   }
   for (int k = 0; k<3; k++)
   {
     translationFloat[k] = m->GetElement(k, 3);
     translationDouble[k] = m->GetElement(k, 3);
   }
   //create affine transform 3D surface
   mitk::AffineTransform3D::Pointer mitkTransform = mitk::AffineTransform3D::New();
   mitkTransform->SetMatrix(rotationDouble);
   mitkTransform->SetOffset(translationDouble);
   //#############################################################################################
 
   //############### object is transformed ##########################
   //save transform
   m_T_ObjectReg = mitk::NavigationData::New(mitkTransform); // this is stored in a member because it is needed for permanent registration later on
 
   //transform surface/image
   //only move image if we have one. Sometimes, this widget is used just to register point sets without images.
   if (m_ImageNode.IsNotNull())
   {
     //first we have to store the original ct image transform to compose it with the new transform later
     mitk::AffineTransform3D::Pointer imageTransform = m_ImageNode->GetData()->GetGeometry()->GetIndexToWorldTransform();
     imageTransform->Compose(mitkTransform);
     mitk::AffineTransform3D::Pointer newImageTransform = mitk::AffineTransform3D::New(); //create new image transform... setting the composed directly leads to an error
     itk::Matrix<mitk::ScalarType, 3, 3> rotationFloatNew = imageTransform->GetMatrix();
     itk::Vector<mitk::ScalarType, 3> translationFloatNew = imageTransform->GetOffset();
     newImageTransform->SetMatrix(rotationFloatNew);
     newImageTransform->SetOffset(translationFloatNew);
     m_ImageNode->GetData()->GetGeometry()->SetIndexToWorldTransform(newImageTransform);
   }
 
   //If this option is set, each point will be transformed and the acutal coordinates of the points change.
   if (this->m_Controls->m_MoveImagePoints->isChecked())
   {
     mitk::PointSet* pointSet_orig = dynamic_cast<mitk::PointSet*>(m_ImageFiducialsNode->GetData());
     mitk::PointSet::Pointer pointSet_moved = mitk::PointSet::New();
 
     for (int i = 0; i < pointSet_orig->GetSize(); i++)
     {
       pointSet_moved->InsertPoint(mitkTransform->TransformPoint(pointSet_orig->GetPoint(i)));
     }
 
     pointSet_orig->Clear();
     for (int i = 0; i < pointSet_moved->GetSize(); i++)
       pointSet_orig->InsertPoint(pointSet_moved->GetPoint(i));
   }
 
   //Do a global reinit
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(m_DataStorage);
 }
diff --git a/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.h b/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.h
index 2c6e5a2ddf..cf8aaf9ee3 100644
--- a/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkFiducialRegistrationWidget.h
@@ -1,132 +1,132 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef _QmitkFiducialRegistrationWidget_H_INCLUDED
 #define _QmitkFiducialRegistrationWidget_H_INCLUDED
 
 #include "ui_QmitkFiducialRegistrationWidget.h"
-#include "QmitkStdMultiWidget.h"
+#include "QmitkAbstractMultiWidget.h"
 #include "MitkIGTUIExports.h"
 #include "mitkNavigationData.h"
 /*!
  * \brief IGT Fiducial Registration Widget
  *
  * Widget used to set fiducial landmarks in the image and to confirm the corresponding landmarks on the world object (patient/phantom).
  *
  * The widget can add tracker fiducials and perform the registration internally. To enable this functionaltity the
  * methods SetDataStorage(), setTrackerNavigationData() and setImageNode() needs to be called before.
  *
  * If Registration should be handled from outside the class the methods SetImageFiducialsNode() and SetTrackerFiducialsNode()
  * must be called, otherwise the QmitkPointListWidget can not work. If SetDataStorage() is not called the widget does nothing
  * internally.
  *
  * \sa IGT
 */
 class MITKIGTUI_EXPORT QmitkFiducialRegistrationWidget : public QWidget
 {
   Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
 public:
 
   QmitkFiducialRegistrationWidget(QWidget* parent);
   ~QmitkFiducialRegistrationWidget() override;
 
   /** Adds the image node which is transformed after "register" is clicked. */
   void setImageNode(mitk::DataNode::Pointer i);
 
   /** Adds the tracker navigation data which is used when "add current instrument position" is clicked. */
   void setTrackerNavigationData(mitk::NavigationData::Pointer t);
 
   /** Sets the data storage. This is required is the widget shoul add tracker points and perform
    *  registrations internally. When not setting the data storage the widget can still be used
    *  by reacting on the signals and do custom actions outside.*/
   void setDataStorage(mitk::DataStorage::Pointer d);
 
   /*!
   \brief enumeration to specify the appearance of the widget.
   'FIDUCIALMODE' is likely to be used for (tracking) fiducial based registration purposes
   'LANDMARKMODE' can be used for any kind of landmark based registration (source landmarks -> target/reference landmarks)
   */
   enum WidgetAppearanceMode
   {
     FIDUCIALMODE,
     LANDMARKMODE
   };
 
   /*!
   \brief set the appearance mode of this widget
   'FIDUCIALMODE' adapts the widget for (tracking) fiducial based registration purposes
   'LANDMARKMODE' adapts the widget for landmark based registration (source landmarks -> target/reference landmarks)
   */
   void SetWidgetAppearanceMode(WidgetAppearanceMode widgetMode);
 
-  void SetMultiWidget(QmitkStdMultiWidget* multiWidget); ///< (Deprecated method. Multiwidget is not required any more.) Set the default stdMultiWidget (needed for the PointListwidget)
+  void SetMultiWidget(QmitkAbstractMultiWidget* multiWidget); ///< (Deprecated method. Multiwidget is not required any more.) Set the default MultiWidget (needed for the PointListwidget)
   void AddSliceNavigationController(mitk::SliceNavigationController* snc); ///< add the slice navigation controller to be used to move the crosshair to the actual point position
   void SetImageFiducialsNode(mitk::DataNode::Pointer imageFiducialsNode); ///< specify data tree node for the image fiducials
   void SetTrackerFiducialsNode(mitk::DataNode::Pointer trackerFiducialsNode); ///< specify data tree node for the tracker fiducials
   mitk::DataNode::Pointer GetImageFiducialsNode(); ///< returns data tree node for the image fiducials
   mitk::DataNode::Pointer GetTrackerFiducialsNode(); ///< returns data tree node for the tracker fiducials
   void SetQualityDisplayText(QString text); ///< sets specific text on the UI (useful to display FRE/TRE...)
 
   /*!
   \brief Specify the name of the source landmarks. Will be used for label and button.
 
   Example: sourceLandmarkName="CT" will result in group box title "CT landmarks" and button text "Add CT landmark".
   */
   void SetSourceLandmarkName(QString sourceLandmarkName);
 
   /*!
   \brief Specify the name of the source landmarks. Will be used for label and button.
 
   Example: targetLandmarkName="CT" will result in group box title "CT landmarks" and button text "Add CT landmark".
   */
   void SetTargetLandmarkName(QString targetLandmarkName);
 
   bool UseICPIsChecked(); ///< returns true if automatic correspondences search is activated else false
   void HideStaticRegistrationRadioButton(bool on); ///< show or hide  "static Fiducial Registration" radio button in the UI
   void HideContinousRegistrationRadioButton(bool on); ///< show or hide  "hybrid continuous Fiducial Registration" radio button in the UI
   void HideFiducialRegistrationGroupBox(); ///< show or hide  "Fiducial Registration method" groupbox in the UI, depending on the visibility of the radio buttons
   void HideUseICPRegistrationCheckbox(bool on); ///< show or hide  "Find fiducial correspondences (needs 6+ fiducial pairs)" check box in the UI
   void HideImageFiducialButton(bool on); ///< show or hide  "Add image fiducial" button in the UI
   void HideTrackingFiducialButton(bool on); ///< show or hide  "Add tracking fiducial" button in the UI
   void AdjustButtonSpacing(); ///< Rearrange spacing when buttons are turned on or off
 
   signals:
     void AddedTrackingFiducial();      ///< signal if a world instrument position was added to a tracking space fiducial
     void AddedImageFiducial();      ///< signal if an image position was added to a image space fiducial
     void PerformFiducialRegistration();        ///< signal if all fiducial were added and registration can be performed
     void FindFiducialCorrespondences(bool on); ///< signal if automatic correspondences search is toggled
 
   protected slots:
     void DisableEditButtonRegistrationImagePoints(bool);///< Disables the edit button of the widget RegistrationImagePoints if the activated variable is true.
     void DisableEditButtonRegistrationTrackingPoints(bool);///< Disables the edit button of the widget RegistrationTrackingPoints if the activated variable is true.
     void AddTrackerPoint();
     void Register();
 
 protected:
 
   void CreateQtPartControl(QWidget *parent);
 
   void CreateConnections();
 
   bool CheckRegistrationInitialization();
 
   Ui::QmitkFiducialRegistrationWidget* m_Controls;  ///< gui widget
-  QmitkStdMultiWidget* m_MultiWidget;
+  QmitkAbstractMultiWidget* m_MultiWidget;
   mitk::DataNode::Pointer m_ImageFiducialsNode;
   mitk::DataNode::Pointer m_TrackerFiducialsNode;
   mitk::DataStorage::Pointer m_DataStorage;
   mitk::NavigationData::Pointer m_TrackerNavigationData;
   mitk::DataNode::Pointer m_ImageNode;
   mitk::NavigationData::Pointer m_T_ObjectReg;
 
 };
 #endif // _QmitkFiducialRegistrationWidget_H_INCLUDED
diff --git a/Modules/ImageExtraction/Testing/mitkExtractDirectedPlaneImageFilterTest.cpp b/Modules/ImageExtraction/Testing/mitkExtractDirectedPlaneImageFilterTest.cpp
index 1bcc6d5245..38ca33881a 100644
--- a/Modules/ImageExtraction/Testing/mitkExtractDirectedPlaneImageFilterTest.cpp
+++ b/Modules/ImageExtraction/Testing/mitkExtractDirectedPlaneImageFilterTest.cpp
@@ -1,293 +1,293 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 //
 //#include "mitkExtractDirectedPlaneImageFilter.h"
 //#include "mitkStandardFileLocations.h"
 //
 //#include <vtkImageData.h>
 //#include <vtkSmartPointer.h>
 //#include <mitkItkImageFileReader.h>
 //#include <vtkActor.h>
 //#include <vtkRenderWindowInteractor.h>
 //
 //#include "mitkTestingMacros.h"
 //
 //#include <iostream>
 //
 //
 // class ExtractionTesting{
 //
 // public:
 //
 //  struct Testcase
 //  {
 //    int number;
 //    std::string name;
 //    std::string imageFilename;
 //    std::string referenceImageFilename;
 //    bool success;
 //    mitk::Geometry2D::Pointer (*GetPlane) (void);
 //  };
 //
 //  static void DoTesting(Testcase &testcase)
 //  {
 //    mitk::Image::Pointer image = GetImageToTest(testcase.imageFilename);
 //    if ( image.IsNull){
 //      testcase.success = false;
 //      return;
 //    }
 //
 //    /*mitk::Image::Pointer referenceImage = GetImageToTest(testcase.referenceImageFilename);
 //    if ( referenceImage.IsNull){
 //      testcase.success = false;
 //      return;
 //    }
 //
 //    mitk::Geometry2D::Pointer directedGeometry2D = testcase.GetPlane();
 //    if(directedGeometry2D.IsNull){
 //      testcase.success = false;*/
 //    }
 //
 //    //put testing here
 //    //TODO vtkIMageREslice setup
 //    //vtkSmartPointer<vtk
 //
 //      vtkSmartPointer<vtkImageData> colorImage = image->GetVtkImageData();
 //
 //    vtkSmartPointer<vtkImageMapper3D> imageMapper = vtkSmartPointer<vtkImageMapper3D>::New();
 //    imageMapper->SetInput(colorImage);
 //
 //
 //    vtkSmartPointer<vtkActor> imageActor = vtkSmartPointer<vtkActor>::New();
 //    imageActor->SetMapper(imageMapper);
 //    //imageActor->SetPosition(20, 20);
 //
 //    // Setup renderers
 //    vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
 //
 //    // Setup render window
 //    vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
 //    renderWindow->AddRenderer(renderer);
 //
 //    // Setup render window interactor
 //    vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
 //    vtkSmartPointer<vtkRenderWindowInteractor>::New();
 //    vtkSmartPointer<vtkInteractorStyleImage> style = vtkSmartPointer<vtkInteractorStyleImage>::New();
 //    renderWindowInteractor->SetInteractorStyle(style);
 //
 //    // Render and start interaction
 //    renderWindowInteractor->SetRenderWindow(renderWindow);
 //    //renderer->AddViewProp(imageActor);
 //    renderer->AddActor(imageActor);
 //
 //    renderWindow->Render();
 //    renderWindowInteractor->Start();
 //  }
 //
 //
 //  static std::vector<testCase> InitializeTestCases()
 //  {
 //    int testcounter = 0;
 //    std::vector<testCase> tests=
 //
 //    //#BEGIN setup TestCases
 //
 //    {
 //      {
 //        ++testcounter,
 //        "TestCoronal",
 //        "image.nrrd",
 //        "coronalReference.nrrd",
 //        false,
 //        &TestCoronal
 //      },
 //      {
 //        ++testcounter,
-//        "TestSagital",
+//        "TestSagittal",
 //        "image.nrrd",
 //        "sagitalReference.nrrd",
 //        false,
-//        &TestSagital
+//        &TestSagittal
 //      },
 //      {
 //        ++testcounter,
 //        "TestCoronal",
 //        "image.nrrd",
 //        "coronalReference.nrrd",
 //        false,
 //        &TestCoronal
 //      },
 //      {
 //        ++testcounter,
 //        "Test_u_Rotation",
 //        "image.nrrd",
 //        "uRotationReference.nrrd",
 //        false,
 //        &Test_u_Rotation
 //      },
 //      {
 //        ++testcounter,
 //        "Test_v_Rotation",
 //        "image.nrrd",
 //        "vRotationReference.nrrd",
 //        false,
 //        &Test_v_Rotation
 //      },
 //      {
 //        ++testcounter,
 //        "TestTwoDirectionalRation",
 //        "image.nrrd",
 //        "twoDirectionalRationReference.nrrd",
 //        false,
 //        &TestTwoDirectionalRotation
 //      },
 //      {
 //        ++testcounter,
 //        "Test4D",
 //        "image.nrrd",
 //        "twoDirectionalRationReference.nrrd",
 //        false,
 //        &Test4D
 //      },
 //      {
 //        ++testcounter,
 //        "Test2D",
 //        "coronalReference.nrrd",
 //        "coronalReference.nrrd",
 //        false,
 //        &Test2D
 //      },
 //      {
 //        ++testcounter,
 //        "Test2D",
 //        nullptr,
 //        nullptr,
 //        false,
 //        &Test1D
 //      }
 //
 //    };
 //
 //    //#END setup TestCases
 //
 //    return tests;
 //  }
 //
 // protected:
 //
 //  static mitk::Image::Pointer GetImageToTest(std::string filename){
 //    //retrieve referenceImage
 //
 ////  mitk::StandardFileLocations::Pointer locator = mitk::StandardFileLocations::GetInstance();
 ////
 ////  const std::string filepath = locator->FindFile(filename, "Modules/MitkExt/Testing/Data");
 ////
 ////  if (filepath.empty())
 ////  {
 ////  return nullptr;
 ////  }
 ////
 //////TODO read imge from file
 ////  itk::FilenamesContainer file;
 ////  file.push_back( filename );
 //    mitk::ItkImageFileReader::Pointer reader = mitk::ItkImageFileReader::New();
 //    reader->SetFileName("C:\home\Pics\Pic3D.nrrd");
 //
 //    reader->Update();
 //
 //    mitk::Image::Pointer image = reader->GetOutput();
 //
 //    return image;
 //  }
 //
 //
-//  static mitk::Geometry2D::Pointer TestSagital()
+//  static mitk::Geometry2D::Pointer TestSagittal()
 //  {
 //
 //    return nullptr;
 //  }
 //
 //  static mitk::Geometry2D::Pointer TestCoronal()
 //  {
 // return nullptr;
 //  }
 //
 //  static mitk::Geometry2D::Pointer TestAxial()
 //  {
 // return nullptr;
 //  }
 //
 //  static mitk::Geometry2D::Pointer Test_u_Rotation()
 //  {
 // return nullptr;
 //  }
 //
 //  static mitk::Geometry2D::Pointer Test_v_Rotation()
 //  {
 // return nullptr;
 //  }
 //
 //  static mitk::Geometry2D::Pointer TestTwoDirectionalRotation()
 //  {
 // return nullptr;
 //  }
 //
 //  static mitk::Geometry2D::Pointer Test4DImage()
 //  {return nullptr;
 //
 //  }
 //
 //  static mitk::Geometry2D::Pointer Test2DImage()
 //  {
 // return nullptr;
 //  }
 //
 //  static mitk::Geometry2D::Pointer Test1DImage()
 //  {
 // return nullptr;
 //  }
 //
 //};
 //
 //
 //**
 // *  Tests for the class "mitkExtractDirectedPlaneImageFilter".
 // *
 // *  argc and argv are the command line parameters which were passed to
 // *  the ADD_TEST command in the CMakeLists.txt file. For the automatic
 // *  tests, argv is either empty for the simple tests or contains the filename
 // *  of a test image for the image tests (see CMakeLists.txt).
 // */
 // int mitkExtractDirectedPlaneImageFilterTest(int /* argc */, char* /*argv*/[])
 //{
 //  // always start with this!
 //  MITK_TEST_BEGIN("mitkExtractDirectedPlaneImageFilter")
 //
 //
 //    mitk::ExtractDirectedPlaneImageFilter::Pointer extractor = mitk::ExtractDirectedPlaneImageFilter::New();
 //  MITK_TEST_CONDITION_REQUIRED(extractor.IsNotNull(),"Testing instantiation")
 //
 //
 //    std::vector<ExtractionTesting::Testcase> allTests = ExtractionTesting::InitializeTestCases();
 //
 //  for( int i = 0; i < allTests.size(); i++);{
 //
 //    ExtractionTesting::Testcase testCase = allTest[i];
 //
 //    ExtractionTesting::DoTesting(testCase);
 //
 //    MITK_TEST_CONDITION(testCase.success, "Testcase #'" << testCase.number << " " << testCase.name);
 //  }
 //
 //  // always end with this!
 //  MITK_TEST_END()
 //}
diff --git a/Modules/ImageExtraction/mitkExtractImageFilter.cpp b/Modules/ImageExtraction/mitkExtractImageFilter.cpp
index 1115c6ebd2..807fc7665c 100644
--- a/Modules/ImageExtraction/mitkExtractImageFilter.cpp
+++ b/Modules/ImageExtraction/mitkExtractImageFilter.cpp
@@ -1,259 +1,259 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkExtractImageFilter.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageCast.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkPlaneGeometry.h"
 
 #include <itkExtractImageFilter.h>
 
 #include <mitkImageAccessByItk.h>
 
 mitk::ExtractImageFilter::ExtractImageFilter()
   : m_SliceIndex(0), m_SliceDimension(0), m_TimeStep(0), m_DirectionCollapseToStrategy(DIRECTIONCOLLAPSETOGUESS)
 {
   MITK_WARN << "Class ExtractImageFilter is deprecated! Use ExtractSliceFilter instead.";
 }
 
 mitk::ExtractImageFilter::~ExtractImageFilter()
 {
 }
 
 void mitk::ExtractImageFilter::GenerateData()
 {
   Image::ConstPointer input = ImageToImageFilter::GetInput(0);
 
   if ((input->GetDimension() > 4) || (input->GetDimension() < 2))
   {
     MITK_ERROR << "mitk::ExtractImageFilter:GenerateData works only with 3D and 3D+t images, sorry." << std::endl;
     itkExceptionMacro("mitk::ExtractImageFilter works only with 3D and 3D+t images, sorry.");
     return;
   }
   else if (input->GetDimension() == 4)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
     timeSelector->SetInput(input);
     timeSelector->SetTimeNr(m_TimeStep);
     timeSelector->UpdateLargestPossibleRegion();
     input = timeSelector->GetOutput();
   }
   else if (input->GetDimension() == 2)
   {
     Image::Pointer resultImage = ImageToImageFilter::GetOutput();
     resultImage = const_cast<Image *>(input.GetPointer());
     ImageToImageFilter::SetNthOutput(0, resultImage);
     return;
   }
 
   if (m_SliceDimension >= input->GetDimension())
   {
     MITK_ERROR << "mitk::ExtractImageFilter:GenerateData  m_SliceDimension == " << m_SliceDimension
                << " makes no sense with an " << input->GetDimension() << "D image." << std::endl;
     itkExceptionMacro("This is not a sensible value for m_SliceDimension.");
     return;
   }
 
   AccessFixedDimensionByItk(input, ItkImageProcessing, 3);
 
   // set a nice geometry for display and point transformations
   BaseGeometry *inputImageGeometry = ImageToImageFilter::GetInput(0)->GetGeometry();
   if (!inputImageGeometry)
   {
     MITK_ERROR << "In ExtractImageFilter::ItkImageProcessing: Input image has no geometry!" << std::endl;
     return;
   }
 
   PlaneGeometry::PlaneOrientation orientation = PlaneGeometry::Axial;
 
   switch (m_SliceDimension)
   {
     default:
     case 2:
       orientation = PlaneGeometry::Axial;
       break;
     case 1:
-      orientation = PlaneGeometry::Frontal;
+      orientation = PlaneGeometry::Coronal;
       break;
     case 0:
       orientation = PlaneGeometry::Sagittal;
       break;
   }
 
   PlaneGeometry::Pointer planeGeometry = PlaneGeometry::New();
   planeGeometry->InitializeStandardPlane(inputImageGeometry, orientation, (ScalarType)m_SliceIndex, true, false);
   Image::Pointer resultImage = ImageToImageFilter::GetOutput();
   planeGeometry->ChangeImageGeometryConsideringOriginOffset(true);
   resultImage->SetGeometry(planeGeometry);
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::ExtractImageFilter::ItkImageProcessing(const itk::Image<TPixel, VImageDimension> *itkImage)
 {
   // use the itk::ExtractImageFilter to get a 2D image
   typedef itk::Image<TPixel, VImageDimension> ImageType3D;
   typedef itk::Image<TPixel, VImageDimension - 1> ImageType2D;
 
   typedef itk::ExtractImageFilter<ImageType3D, ImageType2D> ExtractImageFilterType;
   typename ImageType3D::RegionType inSliceRegion = itkImage->GetLargestPossibleRegion();
 
   inSliceRegion.SetSize(m_SliceDimension, 0);
 
   typename ExtractImageFilterType::Pointer sliceExtractor = ExtractImageFilterType::New();
 
   typename ExtractImageFilterType::DirectionCollapseStrategyEnum collapseStrategy;
   switch (m_DirectionCollapseToStrategy)
   {
     case DIRECTIONCOLLAPSETOUNKOWN:
       collapseStrategy = ExtractImageFilterType::DirectionCollapseStrategyEnum::DIRECTIONCOLLAPSETOUNKOWN;
       break;
     case DIRECTIONCOLLAPSETOIDENTITY:
       collapseStrategy = ExtractImageFilterType::DirectionCollapseStrategyEnum::DIRECTIONCOLLAPSETOIDENTITY;
       break;
     case DIRECTIONCOLLAPSETOSUBMATRIX:
       collapseStrategy = ExtractImageFilterType::DirectionCollapseStrategyEnum::DIRECTIONCOLLAPSETOSUBMATRIX;
       break;
     case DIRECTIONCOLLAPSETOGUESS:
     default:
       collapseStrategy = ExtractImageFilterType::DirectionCollapseStrategyEnum::DIRECTIONCOLLAPSETOGUESS;
       break;
   }
 
   sliceExtractor->SetDirectionCollapseToStrategy(collapseStrategy);
   sliceExtractor->SetInput(itkImage);
 
   inSliceRegion.SetIndex(m_SliceDimension, m_SliceIndex);
 
   sliceExtractor->SetExtractionRegion(inSliceRegion);
 
   // calculate the output
   sliceExtractor->UpdateLargestPossibleRegion();
 
   typename ImageType2D::Pointer slice = sliceExtractor->GetOutput();
 
   // re-import to MITK
   Image::Pointer resultImage = ImageToImageFilter::GetOutput();
   GrabItkImageMemory(slice, resultImage, nullptr, false);
 }
 
 /*
  * What is the input requested region that is required to produce the output
  * requested region? By default, the largest possible region is always
  * required but this is overridden in many subclasses. For instance, for an
  * image processing filter where an output pixel is a simple function of an
  * input pixel, the input requested region will be set to the output
  * requested region. For an image processing filter where an output pixel is
  * a function of the pixels in a neighborhood of an input pixel, then the
  * input requested region will need to be larger than the output requested
  * region (to avoid introducing artificial boundary conditions). This
  * function should never request an input region that is outside the the
  * input largest possible region (i.e. implementations of this method should
  * crop the input requested region at the boundaries of the input largest
  * possible region).
  */
 void mitk::ExtractImageFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   ImageToImageFilter::InputImagePointer input = dynamic_cast<ImageToImageFilter::InputImageType *>(this->GetInput());
   Image::Pointer output = this->GetOutput();
 
   if (input->GetDimension() == 2)
   {
     input->SetRequestedRegionToLargestPossibleRegion();
     return;
   }
 
   Image::RegionType requestedRegion;
   requestedRegion = output->GetRequestedRegion();
   requestedRegion.SetIndex(0, 0);
   requestedRegion.SetIndex(1, 0);
   requestedRegion.SetIndex(2, 0);
   requestedRegion.SetSize(0, input->GetDimension(0));
   requestedRegion.SetSize(1, input->GetDimension(1));
   requestedRegion.SetSize(2, input->GetDimension(2));
 
   requestedRegion.SetIndex(m_SliceDimension, m_SliceIndex); // only one slice needed
   requestedRegion.SetSize(m_SliceDimension, 1);
 
   input->SetRequestedRegion(&requestedRegion);
 }
 
 /*
  * Generate the information decribing the output data. The default
  * implementation of this method will copy information from the input to the
  * output. A filter may override this method if its output will have different
  * information than its input. For instance, a filter that shrinks an image will
  * need to provide an implementation for this method that changes the spacing of
  * the pixels. Such filters should call their superclass' implementation of this
  * method prior to changing the information values they need (i.e.
  * GenerateOutputInformation() should call
  * Superclass::GenerateOutputInformation() prior to changing the information.
  */
 void mitk::ExtractImageFilter::GenerateOutputInformation()
 {
   Image::Pointer output = this->GetOutput();
   Image::ConstPointer input = this->GetInput();
   if (input.IsNull())
     return;
 
   if (m_SliceDimension >= input->GetDimension() && input->GetDimension() != 2)
   {
     MITK_ERROR << "mitk::ExtractImageFilter:GenerateOutputInformation  m_SliceDimension == " << m_SliceDimension
                << " makes no sense with an " << input->GetDimension() << "D image." << std::endl;
     itkExceptionMacro("This is not a sensible value for m_SliceDimension.");
     return;
   }
 
   unsigned int sliceDimension(m_SliceDimension);
   if (input->GetDimension() == 2)
   {
     sliceDimension = 2;
   }
 
   unsigned int tmpDimensions[2];
 
   switch (sliceDimension)
   {
     default:
     case 2:
       // orientation = PlaneGeometry::Axial;
       tmpDimensions[0] = input->GetDimension(0);
       tmpDimensions[1] = input->GetDimension(1);
       break;
     case 1:
-      // orientation = PlaneGeometry::Frontal;
+      // orientation = PlaneGeometry::Coronal;
       tmpDimensions[0] = input->GetDimension(0);
       tmpDimensions[1] = input->GetDimension(2);
       break;
     case 0:
       // orientation = PlaneGeometry::Sagittal;
       tmpDimensions[0] = input->GetDimension(1);
       tmpDimensions[1] = input->GetDimension(2);
       break;
   }
 
   output->Initialize(input->GetPixelType(), 2, tmpDimensions, 1 /*input->GetNumberOfChannels()*/);
 
   // initialize the spacing of the output
   /*
     Vector3D spacing = input->GetSlicedGeometry()->GetSpacing();
     if(input->GetDimension()>=2)
       spacing[2]=spacing[1];
     else
       spacing[2] = 1.0;
     output->GetSlicedGeometry()->SetSpacing(spacing);
   */
 
   output->SetPropertyList(input->GetPropertyList()->Clone());
 }
diff --git a/Modules/ImageStatistics/Testing/mitkImageStatisticsHotspotTest.cpp b/Modules/ImageStatistics/Testing/mitkImageStatisticsHotspotTest.cpp
index b993b0f89e..fff3c3eee2 100644
--- a/Modules/ImageStatistics/Testing/mitkImageStatisticsHotspotTest.cpp
+++ b/Modules/ImageStatistics/Testing/mitkImageStatisticsHotspotTest.cpp
@@ -1,649 +1,650 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkImageStatisticsCalculator.h"
 #include "itkMultiGaussianImageSource.h"
 #include "mitkTestingMacros.h"
 #include "mitkImageCast.h"
 
 #include <itkImageRegionIterator.h>
 
 #include <stdexcept>
 
 #include <itkDOMNode.h>
 #include <itkDOMReader.h>
 
 #include <mitkHotspotMaskGenerator.h>
 #include <mitkImageMaskGenerator.h>
 
 #include <mitkIOUtil.h>
 
 /**
  \section hotspotCalculationTestCases Testcases
 
  To see the different Hotspot-Testcases have a look at the \ref hotspottestdoc.
 
  Note from an intensive session of checking the test results:
   - itk::MultiGaussianImageSource needs a review
   - the test idea is ok, but the combination of XML files for parameters and MultiGaussianImageSource has serious flaws
     - the XML file should contain exactly the parameters that MultiGaussianImageSource requires
     - in contrast, now the XML file mentions index coordinates for gaussian centers while the MultiGaussianImageSource expects world coordinates
       - this requires a transformation (index * spacing assuming no rotation) that was actually broken until recently
 */
 
 struct mitkImageStatisticsHotspotTestClass
 {
   /**
     \brief Test parameters for one test case.
 
     Describes all aspects of a single test case:
      - parameters to generate a test image
      - parameters of a ROI that describes where to calculate statistics
      - expected statistics results
   */
   struct Parameters
   {
   public:
 
     // XML-Tag <testimage>
 
     /** \brief XML-Tag "image-rows": size of x-dimension  */
     int m_ImageRows;
     /** \brief  XML-Tag "image-columns": size of y-dimension  */
     int m_ImageColumns;
     /** \brief  XML-Tag "image-slices": size of z-dimension  */
     int m_ImageSlices;
     /** \brief  XML-Tag "numberOfGaussians": number of used gauss-functions */
     int m_NumberOfGaussian;
 
     /** \brief  XML-Tags "spacingX", "spacingY", "spacingZ": spacing of image in every direction */
     double m_Spacing[3];
 
     /** \brief XML-Tag "entireHotSpotInImage" */
     unsigned int m_EntireHotspotInImage;
 
     // XML-Tag <gaussian>
 
     /**
       \brief  XML-Tag "centerIndexX: gaussian parameter
       \warning This parameter READS the centerIndexX parameter from file and is THEN MISUSED to calculate some position in world coordinates, so we require double.
      */
     std::vector<double> m_CenterX;
     /** \brief  XML-Tag "centerIndexY: gaussian parameter
       \warning This parameter READS the centerIndexX parameter from file and is THEN MISUSED to calculate some position in world coordinates, so we require double.
      */
     std::vector<double> m_CenterY;
     /** \brief  XML-Tag "centerIndexZ: gaussian parameter
       \warning This parameter READS the centerIndexX parameter from file and is THEN MISUSED to calculate some position in world coordinates, so we require double.
      */
     std::vector<double> m_CenterZ;
 
     /** \brief  XML-Tag "deviationX: gaussian parameter  */
     std::vector<double> m_SigmaX;
     /** \brief  XML-Tag "deviationY: gaussian parameter  */
     std::vector<double> m_SigmaY;
     /** \brief  XML-Tag "deviationZ: gaussian parameter  */
     std::vector<double> m_SigmaZ;
 
     /** \brief  XML-Tag "altitude: gaussian parameter  */
     std::vector<double> m_Altitude;
 
     // XML-Tag <segmentation>
 
     /** \brief  XML-Tag "numberOfLabels": number of different labels which appear in the mask */
     unsigned int m_NumberOfLabels;
     /** \brief  XML-Tag "hotspotRadiusInMM": radius of hotspot */
     double m_HotspotRadiusInMM;
 
     // XML-Tag <roi>
 
     /** \brief  XML-Tag "maximumSizeX": maximum position of ROI in x-dimension */
     vnl_vector<int> m_MaxIndexX;
     /** \brief  XML-Tag "minimumSizeX": minimum position of ROI in x-dimension */
     vnl_vector<int> m_MinIndexX;
     /** \brief  XML-Tag "maximumSizeX": maximum position of ROI in y-dimension */
     vnl_vector<int> m_MaxIndexY;
     /** \brief  XML-Tag "minimumSizeX": minimum position of ROI in y-dimension */
     vnl_vector<int> m_MinIndexY;
     /** \brief  XML-Tag "maximumSizeX": maximum position of ROI in z-dimension */
     vnl_vector<int> m_MaxIndexZ;
     /** \brief  XML-Tag "minimumSizeX": minimum position of ROI in z-dimension */
     vnl_vector<int> m_MinIndexZ;
 
     /** \brief  XML-Tag "label": value of label */
     vnl_vector<unsigned int> m_Label;
 
     //XML-Tag <statistic>
 
     /** \brief  XML-Tag "minimum": minimum inside hotspot */
     vnl_vector<double> m_HotspotMin;
     /** \brief  XML-Tag "maximum": maximum inside hotspot */
     vnl_vector<double> m_HotspotMax;
     /** \brief  XML-Tag "mean": mean value of hotspot */
     vnl_vector<double> m_HotspotMean;
 
     /** \brief  XML-Tag "maximumIndexX": x-coordinate of maximum-location inside hotspot */
     vnl_vector<int> m_HotspotMaxIndexX;
     /** \brief  XML-Tag "maximumIndexX": y-coordinate of maximum-location inside hotspot */
     vnl_vector<int> m_HotspotMaxIndexY;
     /** \brief  XML-Tag "maximumIndexX": z-coordinate of maximum-location inside hotspot */
     vnl_vector<int> m_HotspotMaxIndexZ;
 
     /** \brief  XML-Tag "maximumIndexX": x-coordinate of maximum-location inside hotspot */
     vnl_vector<int> m_HotspotMinIndexX;
     /** \brief  XML-Tag "maximumIndexX": y-coordinate of maximum-location inside hotspot */
     vnl_vector<int> m_HotspotMinIndexY;
     /** \brief  XML-Tag "maximumIndexX": z-coordinate of maximum-location inside hotspot */
     vnl_vector<int> m_HotspotMinIndexZ;
 
     /** \brief  XML-Tag "maximumIndexX": x-coordinate of hotspot-location */
     vnl_vector<int> m_HotspotIndexX;
     /** \brief  XML-Tag "maximumIndexX": y-coordinate of hotspot-location */
     vnl_vector<int> m_HotspotIndexY;
     /** \brief  XML-Tag "maximumIndexX": z-coordinate of hotspot-location */
     vnl_vector<int> m_HotspotIndexZ;
   };
 
   /**
     \brief Find/Convert integer attribute in itk::DOMNode.
   */
   static int GetIntegerAttribute(itk::DOMNode* domNode, const std::string& tag)
   {
     assert(domNode);
     MITK_TEST_CONDITION_REQUIRED( domNode->HasAttribute(tag), "Tag '" << tag << "' is defined in test parameters" );
     std::string attributeValue = domNode->GetAttribute(tag);
 
     int resultValue;
     try
     {
       //MITK_TEST_OUTPUT( << "Converting tag value '" << attributeValue << "' for tag '" << tag << "' to integer");
       std::stringstream(attributeValue) >> resultValue;
       return resultValue;
     }
     catch(std::exception& /*e*/)
     {
       MITK_TEST_CONDITION_REQUIRED(false, "Convert tag value '" << attributeValue << "' for tag '" << tag << "' to integer");
       return 0; // just to satisfy compiler
     }
   }
   /**
     \brief Find/Convert double attribute in itk::DOMNode.
   */
   static double GetDoubleAttribute(itk::DOMNode* domNode, const std::string& tag)
   {
     assert(domNode);
     MITK_TEST_CONDITION_REQUIRED( domNode->HasAttribute(tag), "Tag '" << tag << "' is defined in test parameters" );
     std::string attributeValue = domNode->GetAttribute(tag);
 
     double resultValue;
     try
     {
       //MITK_TEST_OUTPUT( << "Converting tag value '" << attributeValue << "' for tag '" << tag << "' to double");
       std::stringstream(attributeValue) >> resultValue;
       return resultValue;
     }
     catch(std::exception& /*e*/)
     {
       MITK_TEST_CONDITION_REQUIRED(false, "Convert tag value '" << attributeValue << "' for tag '" << tag << "' to double");
       return 0.0; // just to satisfy compiler
     }
   }
 
   /**
   \brief Read XML file describing the test parameters.
 
   Reads XML file given in first commandline parameter in order
   to construct a Parameters structure. The XML file should be
   structurs as the following example, i.e. we describe the
   three test aspects of Parameters in four different tags,
   with all the details described as tag attributes. */
 
   /**
   \verbatim
   <testcase>
   <!--
   Test case: multi-label mask
   -->
 
   <testimage image-rows="50" image-columns="50" image-slices="20" numberOfGaussians="2" spacingX="1" spacingY="1" spacingZ="1" entireHotSpotInImage="1">
     <gaussian centerIndexX="10" centerIndexY="10" centerIndexZ="10" deviationX="5" deviationY="5" deviationZ="5" altitude="200"/>
     <gaussian centerIndexX="40" centerIndexY="40" centerIndexZ="10" deviationX="2" deviationY="4" deviationZ="6" altitude="180"/>
   </testimage>
   <segmentation numberOfLabels="2" hotspotRadiusInMM="6.2035">
     <roi label="1" maximumSizeX="20" minimumSizeX="0" maximumSizeY="20" minimumSizeY="0" maximumSizeZ="20" minimumSizeZ="0"/>
     <roi label="2" maximumSizeX="50" minimumSizeX="30" maximumSizeY="50" minimumSizeY="30" maximumSizeZ="20" minimumSizeZ="0"/>
   </segmentation>
   <statistic hotspotIndexX="10" hotspotIndexY="10" hotspotIndexZ="10" mean="122.053" maximumIndexX="10" maximumIndexY="10" maximumIndexZ="10" maximum="200" minimumIndexX="9" minimumIndexY="9" minimumIndexZ="4" minimum="93.5333"/>
   <statistic hotspotIndexX="40" hotspotIndexY="40" hotspotIndexZ="10" mean="61.1749" maximumIndexX="40" maximumIndexY="40" maximumIndexZ="10" maximum="180" minimumIndexX="46" minimumIndexY="39" minimumIndexZ="9" minimum="1.91137"/>
  </testcase>
 
   \endverbatim
   */
   static Parameters ParseParameters(int argc, char* argv[])
   {
     MITK_TEST_CONDITION_REQUIRED(argc == 2, "Test is invoked with exactly 1 parameter (XML parameters file)");
     MITK_INFO << "Reading parameters from file '" << argv[1] << "'";
     std::string filename = argv[1];
 
     Parameters result;
 
     itk::DOMNodeXMLReader::Pointer xmlReader = itk::DOMNodeXMLReader::New();
     xmlReader->SetFileName( filename );
     try
     {
       xmlReader->Update();
       itk::DOMNode::Pointer domRoot = xmlReader->GetOutput();
       typedef std::vector<itk::DOMNode*> NodeList;
       NodeList testimages;
       domRoot->GetChildren("testimage", testimages);
       MITK_TEST_CONDITION_REQUIRED( testimages.size() == 1, "One test image defined" )
       itk::DOMNode* testimage = testimages[0];
 
       result.m_ImageRows = GetIntegerAttribute( testimage, "image-rows" );
       result.m_ImageColumns = GetIntegerAttribute( testimage, "image-columns" );
       result.m_ImageSlices = GetIntegerAttribute( testimage, "image-slices" );
 
       result.m_NumberOfGaussian = GetIntegerAttribute( testimage, "numberOfGaussians" );
 
       result.m_Spacing[0] = GetDoubleAttribute(testimage, "spacingX");
       result.m_Spacing[1] = GetDoubleAttribute(testimage, "spacingY");
       result.m_Spacing[2] = GetDoubleAttribute(testimage, "spacingZ");
 
       result.m_EntireHotspotInImage = GetIntegerAttribute( testimage, "entireHotSpotInImage" );
 
       MITK_TEST_OUTPUT( << "Read size parameters (x,y,z): " << result.m_ImageRows << "," << result.m_ImageColumns << "," << result.m_ImageSlices);
       MITK_TEST_OUTPUT( << "Read spacing parameters (x,y,z): " << result.m_Spacing[0] << "," << result.m_Spacing[1] << "," << result.m_Spacing[2]);
 
       NodeList gaussians;
       testimage->GetChildren("gaussian", gaussians);
       MITK_TEST_CONDITION_REQUIRED( gaussians.size() >= 1, "At least one gaussian is defined" )
 
       result.m_CenterX.resize(result.m_NumberOfGaussian);
       result.m_CenterY.resize(result.m_NumberOfGaussian);
       result.m_CenterZ.resize(result.m_NumberOfGaussian);
 
       result.m_SigmaX.resize(result.m_NumberOfGaussian);
       result.m_SigmaY.resize(result.m_NumberOfGaussian);
       result.m_SigmaZ.resize(result.m_NumberOfGaussian);
 
       result.m_Altitude.resize(result.m_NumberOfGaussian);
 
 
       for(int i = 0; i < result.m_NumberOfGaussian ; ++i)
       {
         itk::DOMNode* gaussian = gaussians[i];
 
         result.m_CenterX[i] = GetIntegerAttribute(gaussian, "centerIndexX");
         result.m_CenterY[i] = GetIntegerAttribute(gaussian, "centerIndexY");
         result.m_CenterZ[i] = GetIntegerAttribute(gaussian, "centerIndexZ");
 
         result.m_SigmaX[i] = GetDoubleAttribute(gaussian, "deviationX");
         result.m_SigmaY[i] = GetDoubleAttribute(gaussian, "deviationY");
         result.m_SigmaZ[i] = GetDoubleAttribute(gaussian, "deviationZ");
 
         result.m_Altitude[i] = GetDoubleAttribute(gaussian, "altitude");
 
         result.m_CenterX[i] = result.m_CenterX[i] * result.m_Spacing[0];
         result.m_CenterY[i] = result.m_CenterY[i] * result.m_Spacing[1];
         result.m_CenterZ[i] = result.m_CenterZ[i] * result.m_Spacing[2];
 
         result.m_SigmaX[i] = result.m_SigmaX[i] * result.m_Spacing[0];
         result.m_SigmaY[i] = result.m_SigmaY[i] * result.m_Spacing[1];
         result.m_SigmaZ[i] = result.m_SigmaZ[i] * result.m_Spacing[2];
       }
 
       NodeList segmentations;
       domRoot->GetChildren("segmentation", segmentations);
       MITK_TEST_CONDITION_REQUIRED( segmentations.size() == 1, "One segmentation defined");
       itk::DOMNode* segmentation = segmentations[0];
 
       result.m_NumberOfLabels = GetIntegerAttribute(segmentation, "numberOfLabels");
       result.m_HotspotRadiusInMM = GetDoubleAttribute(segmentation, "hotspotRadiusInMM");
 
 
       // read ROI parameters, fill result structure
       NodeList rois;
       segmentation->GetChildren("roi", rois);
       MITK_TEST_CONDITION_REQUIRED( rois.size() >= 1, "At least one ROI defined" )
 
       result.m_MaxIndexX.set_size(result.m_NumberOfLabels);
       result.m_MinIndexX.set_size(result.m_NumberOfLabels);
       result.m_MaxIndexY.set_size(result.m_NumberOfLabels);
       result.m_MinIndexY.set_size(result.m_NumberOfLabels);
       result.m_MaxIndexZ.set_size(result.m_NumberOfLabels);
       result.m_MinIndexZ.set_size(result.m_NumberOfLabels);
       result.m_Label.set_size(result.m_NumberOfLabels);
 
       for(unsigned int i = 0; i < rois.size(); ++i)
       {
         result.m_MaxIndexX[i] = GetIntegerAttribute(rois[i], "maximumIndexX");
         result.m_MinIndexX[i] = GetIntegerAttribute(rois[i], "minimumIndexX");
 
         result.m_MaxIndexY[i] = GetIntegerAttribute(rois[i], "maximumIndexY");
         result.m_MinIndexY[i] = GetIntegerAttribute(rois[i], "minimumIndexY");
 
         result.m_MaxIndexZ[i] = GetIntegerAttribute(rois[i], "maximumIndexZ");
         result.m_MinIndexZ[i] = GetIntegerAttribute(rois[i], "minimumIndexZ");
 
         result.m_Label[i] = GetIntegerAttribute(rois[i], "label");
       }
 
       // read statistic parameters, fill result structure
       NodeList statistics;
       domRoot->GetChildren("statistic", statistics);
       MITK_TEST_CONDITION_REQUIRED( statistics.size() >= 1 , "At least one statistic defined" )
       MITK_TEST_CONDITION_REQUIRED( statistics.size() == rois.size(), "Same number of rois and corresponding statistics defined");
 
       result.m_HotspotMin.set_size(statistics.size());
       result.m_HotspotMax.set_size(statistics.size());
       result.m_HotspotMean.set_size(statistics.size());
 
       result.m_HotspotMinIndexX.set_size(statistics.size());
       result.m_HotspotMinIndexY.set_size(statistics.size());
       result.m_HotspotMinIndexZ.set_size(statistics.size());
 
       result.m_HotspotMaxIndexX.set_size(statistics.size());
       result.m_HotspotMaxIndexY.set_size(statistics.size());
       result.m_HotspotMaxIndexZ.set_size(statistics.size());
 
       result.m_HotspotIndexX.set_size(statistics.size());
       result.m_HotspotIndexY.set_size(statistics.size());
       result.m_HotspotIndexZ.set_size(statistics.size());
 
       for(unsigned int i = 0; i < statistics.size(); ++i)
       {
         result.m_HotspotMin[i] = GetDoubleAttribute(statistics[i], "minimum");
         result.m_HotspotMax[i] = GetDoubleAttribute(statistics[i], "maximum");
         result.m_HotspotMean[i] = GetDoubleAttribute(statistics[i], "mean");
 
         result.m_HotspotMinIndexX[i] = GetIntegerAttribute(statistics[i], "minimumIndexX");
         result.m_HotspotMinIndexY[i] = GetIntegerAttribute(statistics[i], "minimumIndexY");
         result.m_HotspotMinIndexZ[i] = GetIntegerAttribute(statistics[i], "minimumIndexZ");
 
         result.m_HotspotMaxIndexX[i] = GetIntegerAttribute(statistics[i], "maximumIndexX");
         result.m_HotspotMaxIndexY[i] = GetIntegerAttribute(statistics[i], "maximumIndexY");
         result.m_HotspotMaxIndexZ[i] = GetIntegerAttribute(statistics[i], "maximumIndexZ");
 
         result.m_HotspotIndexX[i] = GetIntegerAttribute(statistics[i], "hotspotIndexX");
         result.m_HotspotIndexY[i] = GetIntegerAttribute(statistics[i], "hotspotIndexY");
         result.m_HotspotIndexZ[i] = GetIntegerAttribute(statistics[i], "hotspotIndexZ");
       }
     }
     catch (std::exception& e)
     {
       MITK_TEST_CONDITION_REQUIRED(false, "Reading test parameters from XML file. Error message: " << e.what());
     }
 
     return result;
   }
 
   /**
     \brief Generate an image that contains a couple of 3D gaussian distributions.
 
     Uses the given parameters to produce a test image using class MultiGaussianImageSource.
   */
 
   static mitk::Image::Pointer BuildTestImage(const Parameters& testParameters)
   {
     mitk::Image::Pointer result;
 
     typedef double PixelType;
     const int Dimension = 3;
     typedef itk::Image<PixelType, Dimension> ImageType;
     ImageType::Pointer image = ImageType::New();
     typedef itk::MultiGaussianImageSource< ImageType > MultiGaussianImageSource;
     MultiGaussianImageSource::Pointer gaussianGenerator = MultiGaussianImageSource::New();
     ImageType::SizeValueType size[3];
     size[0] = testParameters.m_ImageColumns;
     size[1] = testParameters.m_ImageRows;
     size[2] = testParameters.m_ImageSlices;
 
     itk::MultiGaussianImageSource<ImageType>::VectorType centerXVec, centerYVec, centerZVec, sigmaXVec, sigmaYVec, sigmaZVec, altitudeVec;
 
     for(int i = 0; i < testParameters.m_NumberOfGaussian; ++i)
     {
       centerXVec.push_back(testParameters.m_CenterX[i]);
       centerYVec.push_back(testParameters.m_CenterY[i]);
       centerZVec.push_back(testParameters.m_CenterZ[i]);
 
       sigmaXVec.push_back(testParameters.m_SigmaX[i]);
       sigmaYVec.push_back(testParameters.m_SigmaY[i]);
       sigmaZVec.push_back(testParameters.m_SigmaZ[i]);
 
       altitudeVec.push_back(testParameters.m_Altitude[i]);
     }
 
     ImageType::SpacingType spacing;
 
     for( int i = 0; i < Dimension; ++i )
       spacing[i] = testParameters.m_Spacing[i];
 
     gaussianGenerator->SetSize( size );
     gaussianGenerator->SetSpacing( spacing );
     gaussianGenerator->SetRadius(testParameters.m_HotspotRadiusInMM);
     gaussianGenerator->SetNumberOfGausssians(testParameters.m_NumberOfGaussian);
 
     gaussianGenerator->AddGaussian(centerXVec, centerYVec, centerZVec,
       sigmaXVec, sigmaYVec, sigmaZVec, altitudeVec);
 
     gaussianGenerator->Update();
 
     image = gaussianGenerator->GetOutput();
 
     mitk::CastToMitkImage(image, result);
 
     return result;
   }
 
   /**
     \brief Calculates hotspot statistics for given test image and ROI parameters.
 
     Uses ImageStatisticsCalculator to find a hotspot in a defined ROI within the given image.
   */
   static mitk::ImageStatisticsContainer::ImageStatisticsObject CalculateStatistics(mitk::Image* image, const Parameters& testParameters,  unsigned int label)
   {
     const unsigned int Dimension = 3;
     typedef itk::Image<unsigned short, Dimension> MaskImageType;
     MaskImageType::Pointer mask = MaskImageType::New();
 
     MaskImageType::SizeType size;
     MaskImageType::SpacingType spacing;
     MaskImageType::IndexType start;
 
     mitk::ImageStatisticsCalculator::Pointer statisticsCalculator = mitk::ImageStatisticsCalculator::New();
     statisticsCalculator->SetInputImage(image);
     mitk::Image::Pointer mitkMaskImage;
 
     if((testParameters.m_MaxIndexX[label] > testParameters.m_MinIndexX[label] && testParameters.m_MinIndexX[label] >= 0) &&
       (testParameters.m_MaxIndexY[label] > testParameters.m_MinIndexY[label] && testParameters.m_MinIndexY[label] >= 0) &&
       (testParameters.m_MaxIndexZ[label] > testParameters.m_MinIndexZ[label] && testParameters.m_MinIndexZ[label] >= 0))
     {
       for(unsigned int i = 0; i < Dimension; ++i)
       {
         start[i] = 0;
         spacing[i] = testParameters.m_Spacing[i];
       }
 
       size[0] = testParameters.m_ImageColumns;
       size[1] = testParameters.m_ImageRows;
       size[2] = testParameters.m_ImageSlices;
 
       MaskImageType::RegionType region;
       region.SetIndex(start);
       region.SetSize(size);
 
       mask->SetSpacing(spacing);
       mask->SetRegions(region);
       mask->Allocate();
 
       typedef itk::ImageRegionIteratorWithIndex<MaskImageType> MaskImageIteratorType;
       MaskImageIteratorType maskIt(mask, region);
 
       for(maskIt.GoToBegin(); !maskIt.IsAtEnd(); ++maskIt)
       {
         maskIt.Set(0);
       }
 
       for(unsigned int i = 0; i < testParameters.m_NumberOfLabels; ++i)
       {
 
         for(maskIt.GoToBegin(); !maskIt.IsAtEnd(); ++maskIt)
         {
           MaskImageType::IndexType index = maskIt.GetIndex();
 
           if((index[0] >= testParameters.m_MinIndexX[i]  && index[0] <= testParameters.m_MaxIndexX[i] ) &&
              (index[1] >= testParameters.m_MinIndexY[i]  && index[1] <= testParameters.m_MaxIndexY[i] ) &&
              (index[2] >= testParameters.m_MinIndexZ[i]  && index[2] <= testParameters.m_MaxIndexZ[i] ))
           {
             maskIt.Set(testParameters.m_Label[i]);
           }
         }
       }
 
       mitk::CastToMitkImage(mask, mitkMaskImage);
       mitk::ImageMaskGenerator::Pointer imgMaskGen = mitk::ImageMaskGenerator::New();
+      imgMaskGen->SetInputImage(image);
       imgMaskGen->SetImageMask(mitkMaskImage);
 
       mitk::HotspotMaskGenerator::Pointer hotspotMaskGen = mitk::HotspotMaskGenerator::New();
       hotspotMaskGen->SetInputImage(image);
       hotspotMaskGen->SetLabel(testParameters.m_Label[label]);
       hotspotMaskGen->SetMask(imgMaskGen.GetPointer());
       hotspotMaskGen->SetHotspotRadiusInMM(testParameters.m_HotspotRadiusInMM);
       if(testParameters.m_EntireHotspotInImage == 1)
       {
         MITK_INFO << "Hotspot must be completly inside image";
         hotspotMaskGen->SetHotspotMustBeCompletelyInsideImage(true);
       }
       else
       {
         MITK_INFO << "Hotspot must not be completly inside image";
         hotspotMaskGen->SetHotspotMustBeCompletelyInsideImage(false);
       }
 
       statisticsCalculator->SetMask(hotspotMaskGen.GetPointer());
       MITK_DEBUG << "Masking is set to hotspot+image mask";
     }
     else
     {
       mitk::HotspotMaskGenerator::Pointer hotspotMaskGen = mitk::HotspotMaskGenerator::New();
       hotspotMaskGen->SetInputImage(image);
       hotspotMaskGen->SetHotspotRadiusInMM(testParameters.m_HotspotRadiusInMM);
       if(testParameters.m_EntireHotspotInImage == 1)
       {
         MITK_INFO << "Hotspot must be completly inside image";
         hotspotMaskGen->SetHotspotMustBeCompletelyInsideImage(true);
       }
       else
       {
         MITK_INFO << "Hotspot must not be completly inside image";
         hotspotMaskGen->SetHotspotMustBeCompletelyInsideImage(false);
       }
       MITK_DEBUG << "Masking is set to hotspot only";
     }
 
     return statisticsCalculator->GetStatistics()->GetStatisticsForTimeStep(0);
   }
 
   static void ValidateStatisticsItem(const std::string& label, double testvalue, double reference, double tolerance)
   {
     double diff = ::fabs(reference - testvalue);
     MITK_TEST_CONDITION( diff < tolerance, "'" << label << "' value close enough to reference value "
                                            "(value=" << testvalue <<
                                            ", reference=" << reference <<
                                            ", diff=" << diff << ")" );
   }
 
   static void ValidateStatisticsItem(const std::string& label, const vnl_vector<int>& testvalue, const vnl_vector<int>& reference)
   {
     double diffX = ::fabs(double(testvalue[0] - reference[0]));
     double diffY = ::fabs(double(testvalue[1] - reference[1]));
     double diffZ = ::fabs(double(testvalue[2] - reference[2]));
 
     std::stringstream testPosition;
     testPosition << testvalue[0] << "," << testvalue[1] << "," << testvalue[2];
     std::stringstream referencePosition;
     referencePosition << reference[0] << "," << reference[1] << "," << reference[2];
     MITK_TEST_CONDITION( diffX < mitk::eps && diffY < mitk::eps && diffZ < mitk::eps,
                          "'" << label << "' close enough to reference value " <<
                          "(value=[" << testPosition.str() << "]," <<
                          " reference=[" << referencePosition.str() << "]");
   }
 
 
   /**
     \brief Compares calculated against actual statistics values.
 
     Checks validness of all statistics aspects. Lets test fail if any aspect is not sufficiently equal.
   */
   static void ValidateStatistics(const mitk::ImageStatisticsContainer::ImageStatisticsObject hotspotStatistics, const Parameters& testParameters, unsigned int label)
   {
     // check all expected test result against actual results
     double eps = 0.25; // value above the largest tested difference
 
     auto mean = hotspotStatistics.GetValueConverted<mitk::ImageStatisticsContainer::RealType>(mitk::ImageStatisticsConstants::MEAN());
     auto max = hotspotStatistics.GetValueConverted<mitk::ImageStatisticsContainer::RealType>(mitk::ImageStatisticsConstants::MAXIMUM());
     auto min = hotspotStatistics.GetValueConverted<mitk::ImageStatisticsContainer::RealType>(mitk::ImageStatisticsConstants::MINIMUM());
 
     ValidateStatisticsItem("Hotspot mean", mean, testParameters.m_HotspotMean[label], eps);
     ValidateStatisticsItem("Hotspot maximum", max, testParameters.m_HotspotMax[label], eps);
     ValidateStatisticsItem("Hotspot minimum", min, testParameters.m_HotspotMin[label], eps);
 
     vnl_vector<int> referenceHotspotCenterIndex; referenceHotspotCenterIndex.set_size(3);
     referenceHotspotCenterIndex[0] = testParameters.m_HotspotIndexX[label];
     referenceHotspotCenterIndex[1] = testParameters.m_HotspotIndexY[label];
     referenceHotspotCenterIndex[2] = testParameters.m_HotspotIndexZ[label];
     // ValidateStatisticsItem("Hotspot center position", statistics.GetHotspotStatistics().GetHotspotIndex(), referenceHotspotCenterIndex); TODO: new image statistics calculator does not give hotspot position
 
     // TODO we do not test minimum/maximum positions within the peak/hotspot region, because
     //      these positions are not unique, i.e. there are multiple valid minima/maxima positions.
     //      One solution would be to modify the test cases in order to achive clear positions.
     //      The BETTER/CORRECT solution would be to change the singular position into a set of positions / a region
   }
 };
 /**
   \brief Verifies that hotspot statistics part of ImageStatisticsCalculator.
 
   The test reads parameters from an XML-file to generate a test-image, calculates the hotspot statistics of the image
   and checks if the calculated statistics are the same as the specified values of the XML-file.
 */
 int mitkImageStatisticsHotspotTest(int argc, char* argv[])
 {
   MITK_TEST_BEGIN("mitkImageStatisticsHotspotTest")
     try {
       mitkImageStatisticsHotspotTestClass::Parameters parameters = mitkImageStatisticsHotspotTestClass::ParseParameters(argc,argv);
 
       mitk::Image::Pointer image = mitkImageStatisticsHotspotTestClass::BuildTestImage(parameters);
       MITK_TEST_CONDITION_REQUIRED( image.IsNotNull(), "Generate test image" );
 
       for(unsigned int label = 0; label < parameters.m_NumberOfLabels; ++label)
       {
         mitk::ImageStatisticsContainer::ImageStatisticsObject statistics = mitkImageStatisticsHotspotTestClass::CalculateStatistics(image, parameters, label);
 
         mitkImageStatisticsHotspotTestClass::ValidateStatistics(statistics, parameters, label);
         std::cout << std::endl;
       }
 
 
   }
   catch (std::exception& e)
   {
     std::cout << "Error: " <<  e.what() << std::endl;
     MITK_TEST_CONDITION_REQUIRED( false, "Exception occurred during test execution: " << e.what() );
   }
   catch(...)
   {
     MITK_TEST_CONDITION_REQUIRED( false, "Exception occurred during test execution." );
   }
 
 
   MITK_TEST_END()
 }
diff --git a/Modules/ImageStatistics/mitkHotspotMaskGenerator.cpp b/Modules/ImageStatistics/mitkHotspotMaskGenerator.cpp
index 30c805a19c..35d4a30a8e 100644
--- a/Modules/ImageStatistics/mitkHotspotMaskGenerator.cpp
+++ b/Modules/ImageStatistics/mitkHotspotMaskGenerator.cpp
@@ -1,612 +1,618 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkHotspotMaskGenerator.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkImageCast.h>
 #include <mitkPoint.h>
 #include <itkImageRegionIterator.h>
 #include "mitkImageAccessByItk.h"
 #include <itkImageDuplicator.h>
 #include <itkFFTConvolutionImageFilter.h>
 #include <mitkITKImageImport.h>
 
 namespace mitk
 {
     HotspotMaskGenerator::HotspotMaskGenerator():
         m_HotspotRadiusinMM(6.2035049089940),   // radius of a 1cm3 sphere in mm
         m_HotspotMustBeCompletelyInsideImage(true),
         m_Label(1)
     {
         m_TimeStep = 0;
         m_InternalMask = mitk::Image::New();
         m_InternalMaskUpdateTime = 0;
     }
 
     void HotspotMaskGenerator::SetInputImage(mitk::Image::Pointer inputImage)
     {
         if (inputImage != m_inputImage)
         {
             m_inputImage = inputImage;
             m_ConvolutionImageMaxIndex.set_size(inputImage->GetDimension());
             m_ConvolutionImageMinIndex.set_size(inputImage->GetDimension());
             this->Modified();
         }
     }
 
     void HotspotMaskGenerator::SetMask(MaskGenerator::Pointer mask)
     {
         if (mask != m_Mask)
         {
             m_Mask = mask;
             this->Modified();
         }
     }
 
     HotspotMaskGenerator::~HotspotMaskGenerator()
     {
     }
 
     void HotspotMaskGenerator::SetHotspotRadiusInMM(double radiusInMillimeter)
     {
         if(radiusInMillimeter != m_HotspotRadiusinMM)
         {
             m_HotspotRadiusinMM = radiusInMillimeter;
             this->Modified();
         }
     }
 
     const double& HotspotMaskGenerator::GetHotspotRadiusinMM() const
     {
         return m_HotspotRadiusinMM;
     }
 
     bool HotspotMaskGenerator::GetHotspotMustBeCompletelyInsideImage() const
     {
         return m_HotspotMustBeCompletelyInsideImage;
     }
 
     void HotspotMaskGenerator::SetHotspotMustBeCompletelyInsideImage(bool mustBeCompletelyInImage)
     {
         if (m_HotspotMustBeCompletelyInsideImage != mustBeCompletelyInImage)
         {
             m_HotspotMustBeCompletelyInsideImage = mustBeCompletelyInImage;
             this->Modified();
         }
     }
 
 
-    mitk::Image::Pointer HotspotMaskGenerator::GetMask()
+    mitk::Image::ConstPointer HotspotMaskGenerator::GetMask()
     {
         if (IsUpdateRequired())
         {
             if ( m_inputImage.IsNull() )
             {
               throw std::runtime_error( "Error: image empty!" );
             }
 
             if ( m_TimeStep >= m_inputImage->GetTimeSteps() )
             {
               throw std::runtime_error( "Error: invalid time step!" );
             }
 
             mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
             imageTimeSelector->SetInput( m_inputImage );
             imageTimeSelector->SetTimeNr( m_TimeStep );
             imageTimeSelector->UpdateLargestPossibleRegion();
             mitk::Image::Pointer timeSliceImage = imageTimeSelector->GetOutput();
 
             m_internalImage = timeSliceImage;
             m_internalMask2D = nullptr; // is this correct when this variable holds a smart pointer?
             m_internalMask3D = nullptr;
 
             if ( m_Mask != nullptr )
             {
                 m_Mask->SetTimeStep(m_TimeStep);
-                mitk::Image::Pointer timeSliceMask = m_Mask->GetMask();
+                mitk::Image::ConstPointer timeSliceMask = m_Mask->GetMask();
 
                 if ( m_internalImage->GetDimension() == 3 )
                 {
-                    CastToItkImage(timeSliceMask, m_internalMask3D);
-                    AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 3, m_internalMask3D, m_Label);
+                    itk::Image<unsigned short, 3>::Pointer noneConstMaskImage; //needed to work arround the fact that CastToItkImage currently does not support const itk images.
+                    CastToItkImage(timeSliceMask, noneConstMaskImage);
+                    m_internalMask3D = noneConstMaskImage;
+                    AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 3, m_internalMask3D.GetPointer(), m_Label);
                 }
                 else if ( m_internalImage->GetDimension() == 2 )
                 {
-                    CastToItkImage(timeSliceMask, m_internalMask2D);
-                    AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 2, m_internalMask2D, m_Label);
+                    itk::Image<unsigned short, 2>::Pointer noneConstMaskImage; //needed to work arround the fact that CastToItkImage currently does not support const itk images.
+                    CastToItkImage(timeSliceMask, noneConstMaskImage);
+                    m_internalMask2D = noneConstMaskImage;
+                    AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 2, m_internalMask2D.GetPointer(), m_Label);
                 }
                 else
                 {
                     throw std::runtime_error( "Error: invalid image dimension" );
                 }
             }
             else
             {
 
                 if ( m_internalImage->GetDimension() == 3 )
                 {
-                    AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 3, m_internalMask3D, m_Label);
+                    AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 3, m_internalMask3D.GetPointer(), m_Label);
                 }
                 else if ( m_internalImage->GetDimension() == 2 )
                 {
-                    AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 2, m_internalMask2D, m_Label);
+                    AccessFixedDimensionByItk_2(m_internalImage, CalculateHotspotMask, 2, m_internalMask2D.GetPointer(), m_Label);
                 }
                 else
                 {
                     throw std::runtime_error( "Error: invalid image dimension" );
                 }
             }
             this->Modified();
         }
 
         m_InternalMaskUpdateTime = m_InternalMask->GetMTime();
         return m_InternalMask;
     }
 
     void HotspotMaskGenerator::SetTimeStep(unsigned int timeStep)
     {
         if (m_TimeStep != timeStep)
         {
             m_TimeStep = timeStep;
         }
     }
 
     void HotspotMaskGenerator::SetLabel(unsigned short label)
     {
         if (label != m_Label)
         {
             m_Label = label;
             this->Modified();
         }
     }
 
     vnl_vector<int> HotspotMaskGenerator::GetConvolutionImageMinIndex()
     {
         this->GetMask(); // make sure we are up to date
         return m_ConvolutionImageMinIndex;
     }
 
     vnl_vector<int> HotspotMaskGenerator::GetHotspotIndex()
     {
         this->GetMask(); // make sure we are up to date
         return m_ConvolutionImageMaxIndex;
     }
 
     template <typename TPixel, unsigned int VImageDimension  >
     HotspotMaskGenerator::ImageExtrema
       HotspotMaskGenerator::CalculateExtremaWorld( const itk::Image<TPixel, VImageDimension>* inputImage,
-                                                    typename itk::Image<unsigned short, VImageDimension>::Pointer maskImage,
+                                                    const itk::Image<unsigned short, VImageDimension>* maskImage,
                                                     double neccessaryDistanceToImageBorderInMM,
                                                     unsigned int label )
     {
       typedef itk::Image< TPixel, VImageDimension > ImageType;
       typedef itk::Image< unsigned short, VImageDimension > MaskImageType;
 
       typedef itk::ImageRegionConstIteratorWithIndex<MaskImageType> MaskImageIteratorType;
       typedef itk::ImageRegionConstIteratorWithIndex<ImageType> InputImageIndexIteratorType;
 
       typename ImageType::SpacingType spacing = inputImage->GetSpacing();
 
       ImageExtrema minMax;
       minMax.Defined = false;
       minMax.MaxIndex.set_size(VImageDimension);
       minMax.MaxIndex.set_size(VImageDimension);
 
       typename ImageType::RegionType allowedExtremaRegion = inputImage->GetLargestPossibleRegion();
 
       bool keepDistanceToImageBorders( neccessaryDistanceToImageBorderInMM > 0 );
       if (keepDistanceToImageBorders)
       {
         itk::IndexValueType distanceInPixels[VImageDimension];
         for(unsigned short dimension = 0; dimension < VImageDimension; ++dimension)
         {
           // To confirm that the whole hotspot is inside the image we have to keep a specific distance to the image-borders, which is as long as
           // the radius. To get the amount of indices we divide the radius by spacing and add 0.5 because voxels are center based:
           // For example with a radius of 2.2 and a spacing of 1 two indices are enough because 2.2 / 1 + 0.5 = 2.7 => 2.
           // But with a radius of 2.7 we need 3 indices because 2.7 / 1 + 0.5 = 3.2 => 3
           distanceInPixels[dimension] = int( neccessaryDistanceToImageBorderInMM / spacing[dimension] + 0.5);
         }
 
         allowedExtremaRegion.ShrinkByRadius(distanceInPixels);
       }
 
       InputImageIndexIteratorType imageIndexIt(inputImage, allowedExtremaRegion);
 
       float maxValue = itk::NumericTraits<float>::min();
       float minValue = itk::NumericTraits<float>::max();
 
       typename ImageType::IndexType maxIndex;
       typename ImageType::IndexType minIndex;
 
       for(unsigned short i = 0; i < VImageDimension; ++i)
       {
         maxIndex[i] = 0;
         minIndex[i] = 0;
       }
 
       if (maskImage != nullptr)
       {
         MaskImageIteratorType maskIt(maskImage, maskImage->GetLargestPossibleRegion());
         typename ImageType::IndexType imageIndex;
         typename ImageType::IndexType maskIndex;
 
         for(maskIt.GoToBegin(); !maskIt.IsAtEnd(); ++maskIt)
         {
           imageIndex = maskIndex = maskIt.GetIndex();
 
           if(maskIt.Get() == label)
           {
             if( allowedExtremaRegion.IsInside(imageIndex) )
             {
               imageIndexIt.SetIndex( imageIndex );
               double value = imageIndexIt.Get();
               minMax.Defined = true;
 
               //Calculate minimum, maximum and corresponding index-values
               if( value > maxValue )
               {
                 maxIndex = imageIndexIt.GetIndex();
                 maxValue = value;
               }
 
               if(value < minValue )
               {
                 minIndex = imageIndexIt.GetIndex();
                 minValue = value;
               }
             }
           }
         }
       }
       else
       {
         for(imageIndexIt.GoToBegin(); !imageIndexIt.IsAtEnd(); ++imageIndexIt)
         {
           double value = imageIndexIt.Get();
           minMax.Defined = true;
 
           //Calculate minimum, maximum and corresponding index-values
           if( value > maxValue )
           {
             maxIndex = imageIndexIt.GetIndex();
             maxValue = value;
           }
 
           if(value < minValue )
           {
             minIndex = imageIndexIt.GetIndex();
             minValue = value;
           }
         }
       }
 
       minMax.MaxIndex.set_size(VImageDimension);
       minMax.MinIndex.set_size(VImageDimension);
 
       for(unsigned int i = 0; i < minMax.MaxIndex.size(); ++i)
       {
         minMax.MaxIndex[i] = maxIndex[i];
       }
 
       for(unsigned int i = 0; i < minMax.MinIndex.size(); ++i)
       {
         minMax.MinIndex[i] = minIndex[i];
       }
 
       minMax.Max = maxValue;
       minMax.Min = minValue;
 
       return minMax;
     }
 
     template <unsigned int VImageDimension>
     itk::Size<VImageDimension>
       HotspotMaskGenerator::CalculateConvolutionKernelSize( double spacing[VImageDimension],
                                                              double radiusInMM )
     {
       typedef itk::Image< float, VImageDimension > KernelImageType;
       typedef typename KernelImageType::SizeType SizeType;
       SizeType maskSize;
 
       for(unsigned int i = 0; i < VImageDimension; ++i)
       {
         maskSize[i] = static_cast<int>( 2 * radiusInMM / spacing[i]);
 
         // We always want an uneven size to have a clear center point in the convolution mask
         if(maskSize[i] % 2 == 0 )
         {
           ++maskSize[i];
         }
       }
       return maskSize;
     }
 
     template <unsigned int VImageDimension>
     itk::SmartPointer< itk::Image<float, VImageDimension> >
       HotspotMaskGenerator::GenerateHotspotSearchConvolutionKernel(double mmPerPixel[VImageDimension],
                                                                     double radiusInMM )
     {
       std::stringstream ss;
       for (unsigned int i = 0; i < VImageDimension; ++i)
       {
         ss << mmPerPixel[i];
         if (i < VImageDimension -1)
           ss << ",";
       }
       MITK_DEBUG << "Update convolution kernel for spacing (" << ss.str() << ") and radius " << radiusInMM << "mm";
 
 
       double radiusInMMSquared = radiusInMM * radiusInMM;
       typedef itk::Image< float, VImageDimension > KernelImageType;
       typename KernelImageType::Pointer convolutionKernel = KernelImageType::New();
 
       // Calculate size and allocate mask image
       typedef typename KernelImageType::SizeType SizeType;
       SizeType maskSize = this->CalculateConvolutionKernelSize<VImageDimension>(mmPerPixel, radiusInMM);
 
       mitk::Point3D convolutionMaskCenterIndex;
       convolutionMaskCenterIndex.Fill(0.0);
       for(unsigned int i = 0; i < VImageDimension; ++i)
       {
         convolutionMaskCenterIndex[i] = 0.5 * (double)(maskSize[i]-1);
       }
 
       typedef typename KernelImageType::IndexType IndexType;
       IndexType maskIndex;
       maskIndex.Fill(0);
 
       typedef typename KernelImageType::RegionType RegionType;
       RegionType maskRegion;
       maskRegion.SetSize(maskSize);
       maskRegion.SetIndex(maskIndex);
 
       convolutionKernel->SetRegions(maskRegion);
       convolutionKernel->SetSpacing(mmPerPixel);
       convolutionKernel->Allocate();
 
       // Fill mask image values by subsampling the image grid
       typedef itk::ImageRegionIteratorWithIndex<KernelImageType> MaskIteratorType;
       MaskIteratorType maskIt(convolutionKernel,maskRegion);
 
       int numberOfSubVoxelsPerDimension = 2; // per dimension!
       int numberOfSubVoxels = ::pow( static_cast<float>(numberOfSubVoxelsPerDimension), static_cast<float>(VImageDimension) );
       double subVoxelSizeInPixels = 1.0 / (double)numberOfSubVoxelsPerDimension;
       double valueOfOneSubVoxel = 1.0 / (double)numberOfSubVoxels;
       mitk::Point3D subVoxelIndexPosition;
       double distanceSquared = 0.0;
 
       typedef itk::ContinuousIndex<double, VImageDimension> ContinuousIndexType;
       for(maskIt.GoToBegin(); !maskIt.IsAtEnd(); ++maskIt)
       {
         ContinuousIndexType indexPoint(maskIt.GetIndex());
         mitk::Point3D voxelPosition;
         for (unsigned int dimension = 0; dimension < VImageDimension; ++dimension)
         {
           voxelPosition[dimension] = indexPoint[dimension];
         }
 
         double maskValue = 0.0;
         mitk::Vector3D subVoxelOffset; subVoxelOffset.Fill(0.0);
         // iterate sub-voxels by iterating all possible offsets
         for (subVoxelOffset[0] = -0.5 + subVoxelSizeInPixels / 2.0;
           subVoxelOffset[0] < +0.5;
           subVoxelOffset[0] += subVoxelSizeInPixels)
         {
           for (subVoxelOffset[1] = -0.5 + subVoxelSizeInPixels / 2.0;
             subVoxelOffset[1] < +0.5;
             subVoxelOffset[1] += subVoxelSizeInPixels)
           {
             for (subVoxelOffset[2] = -0.5 + subVoxelSizeInPixels / 2.0;
               subVoxelOffset[2] < +0.5;
               subVoxelOffset[2] += subVoxelSizeInPixels)
             {
               subVoxelIndexPosition = voxelPosition + subVoxelOffset; // this COULD be integrated into the for-loops if neccessary (add voxelPosition to initializer and end condition)
               distanceSquared =
                 (subVoxelIndexPosition[0]-convolutionMaskCenterIndex[0]) * mmPerPixel[0] * (subVoxelIndexPosition[0]-convolutionMaskCenterIndex[0]) * mmPerPixel[0]
               + (subVoxelIndexPosition[1]-convolutionMaskCenterIndex[1]) * mmPerPixel[1] * (subVoxelIndexPosition[1]-convolutionMaskCenterIndex[1]) * mmPerPixel[1]
               + (subVoxelIndexPosition[2]-convolutionMaskCenterIndex[2]) * mmPerPixel[2] * (subVoxelIndexPosition[2]-convolutionMaskCenterIndex[2]) * mmPerPixel[2];
 
               if (distanceSquared <= radiusInMMSquared)
               {
                 maskValue += valueOfOneSubVoxel;
               }
             }
           }
         }
         maskIt.Set( maskValue );
       }
 
       return convolutionKernel;
     }
 
     template <typename TPixel, unsigned int VImageDimension>
     itk::SmartPointer<itk::Image<TPixel, VImageDimension> >
       HotspotMaskGenerator::GenerateConvolutionImage( const itk::Image<TPixel, VImageDimension>* inputImage )
     {
       double mmPerPixel[VImageDimension];
       for (unsigned int dimension = 0; dimension < VImageDimension; ++dimension)
       {
         mmPerPixel[dimension] = inputImage->GetSpacing()[dimension];
       }
 
       // update convolution kernel
       typedef itk::Image< float, VImageDimension > KernelImageType;
       typename KernelImageType::Pointer convolutionKernel = this->GenerateHotspotSearchConvolutionKernel<VImageDimension>(mmPerPixel, m_HotspotRadiusinMM);
 
       // update convolution image
       typedef itk::Image< TPixel, VImageDimension > InputImageType;
       typedef itk::Image< TPixel, VImageDimension > ConvolutionImageType;
       typedef itk::FFTConvolutionImageFilter<InputImageType,
         KernelImageType,
         ConvolutionImageType> ConvolutionFilterType;
 
       typename ConvolutionFilterType::Pointer convolutionFilter = ConvolutionFilterType::New();
       typedef itk::ConstantBoundaryCondition<InputImageType, InputImageType> BoundaryConditionType;
       BoundaryConditionType boundaryCondition;
       boundaryCondition.SetConstant(0.0);
 
       if (m_HotspotMustBeCompletelyInsideImage)
       {
         // overwrite default boundary condition
         convolutionFilter->SetBoundaryCondition(&boundaryCondition);
       }
 
       convolutionFilter->SetInput(inputImage);
       convolutionFilter->SetKernelImage(convolutionKernel);
       convolutionFilter->SetNormalize(true);
       MITK_DEBUG << "Update Convolution image for hotspot search";
       convolutionFilter->UpdateLargestPossibleRegion();
 
       typename ConvolutionImageType::Pointer convolutionImage = convolutionFilter->GetOutput();
       convolutionImage->SetSpacing( inputImage->GetSpacing() ); // only workaround because convolution filter seems to ignore spacing of input image
 
       return convolutionImage;
     }
 
     template < typename TPixel, unsigned int VImageDimension>
     void
       HotspotMaskGenerator::FillHotspotMaskPixels( itk::Image<TPixel, VImageDimension>* maskImage,
                                                 itk::Point<double, VImageDimension> sphereCenter,
                                                 double sphereRadiusInMM )
     {
       typedef itk::Image< TPixel, VImageDimension > MaskImageType;
       typedef itk::ImageRegionIteratorWithIndex<MaskImageType> MaskImageIteratorType;
 
       MaskImageIteratorType maskIt(maskImage, maskImage->GetLargestPossibleRegion());
 
       typename MaskImageType::IndexType maskIndex;
       typename MaskImageType::PointType worldPosition;
 
       // this is not very smart. I would rather use a 0 initialized mask (not the case here -> blame CalculateHotspotMask) and find the region where I need to iterate over, then iterate only over the small region
       for(maskIt.GoToBegin(); !maskIt.IsAtEnd(); ++maskIt)
       {
         maskIndex = maskIt.GetIndex();
         maskImage->TransformIndexToPhysicalPoint(maskIndex, worldPosition);
         maskIt.Set( worldPosition.EuclideanDistanceTo(sphereCenter) <= sphereRadiusInMM ? 1 : 0 );
       }
     }
 
     template <typename TPixel, unsigned int VImageDimension>
     void
       HotspotMaskGenerator::CalculateHotspotMask(itk::Image<TPixel, VImageDimension>* inputImage,
-                                              typename itk::Image<unsigned short, VImageDimension>::Pointer maskImage,
+                                              const itk::Image<unsigned short, VImageDimension>* maskImage,
                                               unsigned int label)
     {
         typedef itk::Image< TPixel, VImageDimension > InputImageType;
         typedef itk::Image< TPixel, VImageDimension > ConvolutionImageType;
         typedef itk::Image< unsigned short, VImageDimension > MaskImageType;
 
         typename ConvolutionImageType::Pointer convolutionImage = this->GenerateConvolutionImage(inputImage);
 
         if (convolutionImage.IsNull())
         {
           MITK_ERROR << "Empty convolution image in CalculateHotspotStatistics(). We should never reach this state (logic error).";
           throw std::logic_error("Empty convolution image in CalculateHotspotStatistics()");
         }
 
+        typename MaskImageType::ConstPointer usedMask = maskImage;
         // if mask image is not defined, create an image of the same size as inputImage and fill it with 1's
         // there is maybe a better way to do this!?
         if (maskImage == nullptr)
         {
-            maskImage = MaskImageType::New();
+            auto defaultMask = MaskImageType::New();
             typename MaskImageType::RegionType maskRegion = inputImage->GetLargestPossibleRegion();
             typename MaskImageType::SpacingType maskSpacing = inputImage->GetSpacing();
             typename MaskImageType::PointType maskOrigin = inputImage->GetOrigin();
             typename MaskImageType::DirectionType maskDirection = inputImage->GetDirection();
-            maskImage->SetRegions(maskRegion);
-            maskImage->Allocate();
-            maskImage->SetOrigin(maskOrigin);
-            maskImage->SetSpacing(maskSpacing);
-            maskImage->SetDirection(maskDirection);
+            defaultMask->SetRegions(maskRegion);
+            defaultMask->Allocate();
+            defaultMask->SetOrigin(maskOrigin);
+            defaultMask->SetSpacing(maskSpacing);
+            defaultMask->SetDirection(maskDirection);
 
-            maskImage->FillBuffer(1);
+            defaultMask->FillBuffer(1);
 
+            usedMask = defaultMask;
             label = 1;
         }
 
         // find maximum in convolution image, given the current mask
         double requiredDistanceToBorder = m_HotspotMustBeCompletelyInsideImage ? m_HotspotRadiusinMM : -1.0;
-        ImageExtrema convolutionImageInformation = CalculateExtremaWorld(convolutionImage.GetPointer(), maskImage, requiredDistanceToBorder, label);
+        ImageExtrema convolutionImageInformation = CalculateExtremaWorld(convolutionImage.GetPointer(), usedMask.GetPointer(), requiredDistanceToBorder, label);
 
         bool isHotspotDefined = convolutionImageInformation.Defined;
 
         if (!isHotspotDefined)
         {
           MITK_ERROR << "No origin of hotspot-sphere was calculated!";
           m_InternalMask = nullptr;
         }
         else
         {
           // create a binary mask around the "hotspot" region, fill the shape of a sphere around our hotspot center
 //          typename DuplicatorType::Pointer copyMachine = DuplicatorType::New();
 //          copyMachine->SetInputImage(inputImage);
 //          copyMachine->Update();
 
 //          typename CastFilterType::Pointer caster = CastFilterType::New();
 //          caster->SetInput( copyMachine->GetOutput() );
 //          caster->Update();
           typename MaskImageType::Pointer hotspotMaskITK = MaskImageType::New();
           hotspotMaskITK->SetOrigin(inputImage->GetOrigin());
           hotspotMaskITK->SetSpacing(inputImage->GetSpacing());
           hotspotMaskITK->SetLargestPossibleRegion(inputImage->GetLargestPossibleRegion());
           hotspotMaskITK->SetBufferedRegion(inputImage->GetBufferedRegion());
           hotspotMaskITK->SetDirection(inputImage->GetDirection());
           hotspotMaskITK->SetNumberOfComponentsPerPixel(inputImage->GetNumberOfComponentsPerPixel());
           hotspotMaskITK->Allocate();
           hotspotMaskITK->FillBuffer(1);
 
           typedef typename InputImageType::IndexType IndexType;
           IndexType maskCenterIndex;
           for (unsigned int d =0; d< VImageDimension;++d)
           {
               maskCenterIndex[d]=convolutionImageInformation.MaxIndex[d];
           }
 
           typename ConvolutionImageType::PointType maskCenter;
           inputImage->TransformIndexToPhysicalPoint(maskCenterIndex,maskCenter);
 
           FillHotspotMaskPixels(hotspotMaskITK.GetPointer(), maskCenter, m_HotspotRadiusinMM);
 
           //obtain mitk::Image::Pointer from itk::Image
           mitk::Image::Pointer hotspotMaskAsMITKImage = mitk::GrabItkImageMemory(hotspotMaskITK);
 
           m_InternalMask = hotspotMaskAsMITKImage;
           m_ConvolutionImageMaxIndex = convolutionImageInformation.MaxIndex;
           m_ConvolutionImageMinIndex = convolutionImageInformation.MinIndex;
         }
     }
 
     bool HotspotMaskGenerator::IsUpdateRequired() const
     {
         unsigned long thisClassTimeStamp = this->GetMTime();
         unsigned long internalMaskTimeStamp = m_InternalMask->GetMTime();
         unsigned long maskGeneratorTimeStamp = m_Mask->GetMTime();
         unsigned long inputImageTimeStamp = m_inputImage->GetMTime();
 
         if (thisClassTimeStamp > m_InternalMaskUpdateTime) // inputs have changed
         {
             return true;
         }
 
         if (m_InternalMaskUpdateTime < maskGeneratorTimeStamp || m_InternalMaskUpdateTime < inputImageTimeStamp) // mask image has changed outside of this class
         {
             return true;
         }
 
         if (internalMaskTimeStamp > m_InternalMaskUpdateTime) // internal mask has been changed outside of this class
         {
             return true;
         }
 
         return false;
     }
 }
diff --git a/Modules/ImageStatistics/mitkHotspotMaskGenerator.h b/Modules/ImageStatistics/mitkHotspotMaskGenerator.h
index 724538410e..e23299db6a 100644
--- a/Modules/ImageStatistics/mitkHotspotMaskGenerator.h
+++ b/Modules/ImageStatistics/mitkHotspotMaskGenerator.h
@@ -1,179 +1,180 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKHOTSPOTCALCULATOR_H
 #define MITKHOTSPOTCALCULATOR_H
 
 #include <itkObject.h>
 #include <mitkImage.h>
 #include <itkImage.h>
 #include <itkTimeStamp.h>
 #include <stdexcept>
 #include <MitkImageStatisticsExports.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkMaskGenerator.h>
 
 
 namespace mitk
 {
 /**
      * @brief The HotspotMaskGenerator class is used when a hotspot has to be found in an image. A hotspot is
      * the region of the image where the mean intensity is maximal (=brightest spot). It is usually used in PET scans.
      * The identification of the hotspot is done as follows: First a cubic (or circular, if image is 2d)
      * mask of predefined size is generated. This mask is then convolved with the input image (in fourier domain).
      * The maximum value of the convolved image then corresponds to the hotspot.
      * If a maskGenerator is set, only the pixels of the convolved image where the corresponding mask is == @a label
      * are searched for the maximum value.
      */
     class MITKIMAGESTATISTICS_EXPORT HotspotMaskGenerator: public MaskGenerator
     {
     public:
         /** Standard Self typedef */
         typedef HotspotMaskGenerator                Self;
         typedef MaskGenerator                       Superclass;
         typedef itk::SmartPointer< Self >           Pointer;
         typedef itk::SmartPointer< const Self >     ConstPointer;
 
         /** Method for creation through the object factory. */
         itkNewMacro(Self); /** Runtime information support. */
         itkTypeMacro(HotspotMaskGenerator, MaskGenerator);
 
         /**
         @brief Set the input image. Required for this class
          */
         void SetInputImage(mitk::Image::Pointer inputImage);
 
         /**
         @brief Set a mask (can be nullptr if no mask is desired)
          */
         void SetMask(MaskGenerator::Pointer mask);
 
         /**
         @brief Set the radius of the hotspot (in MM)
          */
         void SetHotspotRadiusInMM(double radiusInMillimeter);
 
         const double& GetHotspotRadiusinMM() const;
 
         /**
         @brief Define whether the hotspot must be completely inside the image. Default is true
          */
         void SetHotspotMustBeCompletelyInsideImage(bool hotspotCompletelyInsideImage);
 
         bool GetHotspotMustBeCompletelyInsideImage() const;
 
         /**
         @brief If a maskGenerator is set, this detemines which mask value is used
          */
         void SetLabel(unsigned short label);
 
         /**
         @brief Computes and returns the hotspot mask. The hotspot mask has the same size as the input image. The hopspot has value 1, the remaining pixels are set to 0
          */
-        mitk::Image::Pointer GetMask() override;
+        mitk::Image::ConstPointer GetMask() override;
 
         /**
         @brief Returns the image index where the hotspot is located
          */
         vnl_vector<int> GetHotspotIndex();
 
         /**
         @brief Returns the index where the convolution image is minimal (darkest spot in image)
          */
         vnl_vector<int> GetConvolutionImageMinIndex();
 
         /**
          * @brief SetTimeStep is used to set the time step for which the mask is to be generated
          * @param timeStep
          */
         void SetTimeStep(unsigned int timeStep) override;
 
     protected:
         HotspotMaskGenerator();
 
         ~HotspotMaskGenerator() override;
 
         class ImageExtrema
         {
         public:
           bool Defined;
           double Max;
           double Min;
           vnl_vector<int> MaxIndex;
           vnl_vector<int> MinIndex;
 
           ImageExtrema()
             :Defined(false)
             ,Max(itk::NumericTraits<double>::min())
             ,Min(itk::NumericTraits<double>::max())
           {
           }
         };
 
     private:
         /** \brief Returns size of convolution kernel depending on spacing and radius. */
         template <unsigned int VImageDimension>
         itk::Size<VImageDimension>
           CalculateConvolutionKernelSize(double spacing[VImageDimension], double radiusInMM);
 
         /** \brief Generates image of kernel which is needed for convolution. */
         template <unsigned int VImageDimension>
         itk::SmartPointer< itk::Image<float, VImageDimension> >
           GenerateHotspotSearchConvolutionKernel(double spacing[VImageDimension], double radiusInMM);
 
         /** \brief Convolves image with spherical kernel image. Used for hotspot calculation.   */
         template <typename TPixel, unsigned int VImageDimension>
         itk::SmartPointer< itk::Image<TPixel, VImageDimension> >
           GenerateConvolutionImage( const itk::Image<TPixel, VImageDimension>* inputImage );
 
 
         /** \brief Fills pixels of the spherical hotspot mask. */
         template < typename TPixel, unsigned int VImageDimension>
         void
           FillHotspotMaskPixels( itk::Image<TPixel, VImageDimension>* maskImage,
           itk::Point<double, VImageDimension> sphereCenter,
           double sphereRadiusInMM);
 
 
         /** \brief */
         template <typename TPixel, unsigned int VImageDimension>
         void
           CalculateHotspotMask(itk::Image<TPixel, VImageDimension>* inputImage,
-                               typename itk::Image<unsigned short, VImageDimension>::Pointer maskImage,
+                               const itk::Image<unsigned short, VImageDimension>* maskImage,
                                unsigned int label);
 
 
         template <typename TPixel, unsigned int VImageDimension  >
         ImageExtrema CalculateExtremaWorld( const itk::Image<TPixel, VImageDimension>* inputImage,
-                                                        typename itk::Image<unsigned short, VImageDimension>::Pointer maskImage,
+                                                        const itk::Image<unsigned short, VImageDimension>* maskImage,
                                                         double neccessaryDistanceToImageBorderInMM,
                                                         unsigned int label);
 
         bool IsUpdateRequired() const;
 
         HotspotMaskGenerator(const HotspotMaskGenerator &);
         HotspotMaskGenerator & operator=(const HotspotMaskGenerator &);
 
         MaskGenerator::Pointer m_Mask;
+        mitk::Image::Pointer m_InternalMask;
         mitk::Image::Pointer m_internalImage;
-        itk::Image<unsigned short, 2>::Pointer m_internalMask2D;
-        itk::Image<unsigned short, 3>::Pointer m_internalMask3D;
+        itk::Image<unsigned short, 2>::ConstPointer m_internalMask2D;
+        itk::Image<unsigned short, 3>::ConstPointer m_internalMask3D;
         double m_HotspotRadiusinMM;
         bool m_HotspotMustBeCompletelyInsideImage;
         unsigned short m_Label;
         vnl_vector<int> m_ConvolutionImageMinIndex, m_ConvolutionImageMaxIndex;
         unsigned long m_InternalMaskUpdateTime;
     };
 }
 #endif // MITKHOTSPOTCALCULATOR
 
 
diff --git a/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.cpp b/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.cpp
index 3f35368492..ad1787bc84 100644
--- a/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.cpp
+++ b/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.cpp
@@ -1,132 +1,132 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkIgnorePixelMaskGenerator.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkImageAccessByItk.h>
 #include <itkImageIterator.h>
 #include <itkImageConstIterator.h>
 #include <mitkITKImageImport.h>
 
 namespace mitk
 {
 void IgnorePixelMaskGenerator::SetIgnoredPixelValue(RealType pixelValue)
 {
     if (pixelValue != m_IgnoredPixelValue)
     {
         m_IgnoredPixelValue = pixelValue;
         this->Modified();
     }
 }
 
 void IgnorePixelMaskGenerator::SetTimeStep(unsigned int timeStep)
 {
     if (m_TimeStep != timeStep)
     {
         m_TimeStep = timeStep;
     }
 }
 
-mitk::Image::Pointer IgnorePixelMaskGenerator::GetMask()
+mitk::Image::ConstPointer IgnorePixelMaskGenerator::GetMask()
 {
     if (IsUpdateRequired())
     {
         if (m_inputImage.IsNull())
         {
             MITK_ERROR << "Image not set!";
         }
 
         if (m_IgnoredPixelValue == std::numeric_limits<RealType>::min())
         {
             MITK_ERROR << "IgnotePixelValue not set!";
         }
 
         if (m_TimeStep > (m_inputImage->GetTimeSteps() - 1))
         {
             MITK_ERROR << "Invalid time step: " << m_TimeStep << ". The image has " << m_inputImage->GetTimeSteps() << " timeSteps!";
         }
 
         // extractimage time slice
         ImageTimeSelector::Pointer imgTimeSel = ImageTimeSelector::New();
         imgTimeSel->SetInput(m_inputImage);
         imgTimeSel->SetTimeNr(m_TimeStep);
         imgTimeSel->UpdateLargestPossibleRegion();
 
         mitk::Image::Pointer timeSliceImage = imgTimeSel->GetOutput();
 
         // update m_InternalMask
         AccessByItk(timeSliceImage, InternalCalculateMask);
         m_InternalMask->SetGeometry(timeSliceImage->GetGeometry());
 
         this->Modified();
     }
     m_InternalMaskUpdateTime = m_InternalMask->GetMTime();
     return m_InternalMask;
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void IgnorePixelMaskGenerator::InternalCalculateMask(typename itk::Image<TPixel, VImageDimension>* image)
 {
     typedef itk::Image<TPixel, VImageDimension> ImageType;
     typedef itk::Image<unsigned short, VImageDimension> MaskType;
 
     typename MaskType::Pointer mask = MaskType::New();
     mask->SetOrigin(image->GetOrigin());
     mask->SetSpacing(image->GetSpacing());
     mask->SetLargestPossibleRegion(image->GetLargestPossibleRegion());
     mask->SetBufferedRegion(image->GetBufferedRegion());
     mask->SetDirection(image->GetDirection());
     mask->SetNumberOfComponentsPerPixel(image->GetNumberOfComponentsPerPixel());
     mask->Allocate();
     mask->FillBuffer(1);
 
     // iterate over image and mask and set mask=1 if image=m_IgnorePixelValue
     itk::ImageRegionConstIterator<ImageType> imageIterator(image, image->GetLargestPossibleRegion());
     itk::ImageRegionIterator<MaskType> maskIterator(mask, mask->GetLargestPossibleRegion());
 
 
     for (imageIterator.GoToBegin(); !imageIterator.IsAtEnd(); ++imageIterator, ++maskIterator)
     {
         if (imageIterator.Value() == static_cast<TPixel>(m_IgnoredPixelValue))
         {
             maskIterator.Set(0);
         }
     }
 
     m_InternalMask = GrabItkImageMemory(mask);
 }
 
 bool IgnorePixelMaskGenerator::IsUpdateRequired() const
 {
     unsigned long thisClassTimeStamp = this->GetMTime();
     unsigned long internalMaskTimeStamp = m_InternalMask->GetMTime();
     unsigned long inputImageTimeStamp = m_inputImage->GetMTime();
 
     if (thisClassTimeStamp > m_InternalMaskUpdateTime) // inputs have changed
     {
         return true;
     }
 
     if (m_InternalMaskUpdateTime < inputImageTimeStamp) // mask image has changed outside of this class
     {
         return true;
     }
 
     if (internalMaskTimeStamp > m_InternalMaskUpdateTime) // internal mask has been changed outside of this class
     {
         return true;
     }
 
     return false;
 }
 
 } // end namespace
diff --git a/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.h b/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.h
index 08b70337fd..550405c385 100644
--- a/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.h
+++ b/Modules/ImageStatistics/mitkIgnorePixelMaskGenerator.h
@@ -1,83 +1,84 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKIGNOREPIXELMASKGEN_
 #define MITKIGNOREPIXELMASKGEN_
 
 #include <mitkImage.h>
 #include <MitkImageStatisticsExports.h>
 #include <mitkMaskGenerator.h>
 #include <limits>
 #include <itkImage.h>
 
 
 namespace mitk
 {
 /**
  * @brief The IgnorePixelMaskGenerator class is used to generate a mask that is zero for specific pixel values in the input image. This class requires an input image.
  */
 class MITKIMAGESTATISTICS_EXPORT IgnorePixelMaskGenerator: public MaskGenerator
 {
 public:
     /** Standard Self typedef */
     typedef IgnorePixelMaskGenerator            Self;
     typedef MaskGenerator                       Superclass;
     typedef itk::SmartPointer< Self >           Pointer;
     typedef itk::SmartPointer< const Self >     ConstPointer;
     typedef double RealType;
 
     /** Method for creation through the object factory. */
     itkNewMacro(Self); /** Runtime information support. */
     itkTypeMacro(IgnorePixelMaskGenerator, MaskGenerator);
 
     /**
      * @brief The mask will be 0 there inputImage==pixelValue and 1 otherwise
      */
     void SetIgnoredPixelValue(RealType pixelValue);
 
     /**
      * @brief Computes and returns the mask
      */
-    mitk::Image::Pointer GetMask() override;
+    mitk::Image::ConstPointer GetMask() override;
 
     /**
      * @brief SetTimeStep is used to set the time step for which the mask is to be generated
      * @param timeStep
      */
     void SetTimeStep(unsigned int timeStep) override;
 
 protected:
     IgnorePixelMaskGenerator():
        m_IgnoredPixelValue(std::numeric_limits<RealType>::min())
     {
         m_TimeStep = 0;
         m_InternalMaskUpdateTime = 0;
         m_InternalMask = mitk::Image::New();
     }
 
     ~IgnorePixelMaskGenerator() override{}
 
     template <typename TPixel, unsigned int VImageDimension>
     void InternalCalculateMask(typename itk::Image<TPixel, VImageDimension>* image);
 
 private:
     bool IsUpdateRequired() const;
 
+    mitk::Image::Pointer m_InternalMask;
     RealType m_IgnoredPixelValue;
     unsigned long m_InternalMaskUpdateTime;
 
 
 };
 
 }
 
 #endif
diff --git a/Modules/ImageStatistics/mitkImageMaskGenerator.cpp b/Modules/ImageStatistics/mitkImageMaskGenerator.cpp
index d8f37a4e21..abf894aca5 100644
--- a/Modules/ImageStatistics/mitkImageMaskGenerator.cpp
+++ b/Modules/ImageStatistics/mitkImageMaskGenerator.cpp
@@ -1,98 +1,99 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkImageMaskGenerator.h>
 #include <mitkImageTimeSelector.h>
 #include <stdexcept>
 
 namespace mitk {
 
-void ImageMaskGenerator::SetImageMask(Image::Pointer maskImage)
+void ImageMaskGenerator::SetImageMask(const Image* maskImage)
 {
-    if (m_internalMaskImage != maskImage)
+    if (m_InternalMaskImage != maskImage)
     {
-        m_internalMaskImage = maskImage;
+        m_InternalMaskImage = maskImage;
         this->Modified();
     }
 }
 
 void ImageMaskGenerator::SetTimeStep(unsigned int timeStep)
 {
     if (timeStep != m_TimeStep)
     {
         m_TimeStep = timeStep;
         UpdateInternalMask();
     }
 }
 
 void ImageMaskGenerator::UpdateInternalMask()
 {
-    unsigned int timeStepForExtraction;
-
-    if (m_TimeStep >= m_internalMaskImage->GetTimeSteps())
-    {
-        MITK_WARN << "Warning: time step > number of time steps in mask image, using last time step";
-        timeStepForExtraction = m_internalMaskImage->GetTimeSteps() - 1;
-    }
-    else
-    {
-        timeStepForExtraction = m_TimeStep;
-    }
-    ImageTimeSelector::Pointer imageTimeSelector = ImageTimeSelector::New();
-    imageTimeSelector->SetInput(m_internalMaskImage);
-    imageTimeSelector->SetTimeNr(timeStepForExtraction);
-    imageTimeSelector->UpdateLargestPossibleRegion();
-
-    m_InternalMask = mitk::Image::New();
-    m_InternalMask = imageTimeSelector->GetOutput();
+  if (this->m_inputImage.IsNull())
+  {
+    mitkThrow() << "Cannot update internal mask. Input image is not set.";
+  }
+
+  const auto timeGeo = this->m_inputImage->GetTimeGeometry();
+  if (!timeGeo->IsValidTimeStep(this->m_TimeStep))
+  {
+    mitkThrow() << "Cannot update internal mask. Time step selected that is not supported by input image.";
+  }
+
+  auto timePoint = this->m_inputImage->GetTimeGeometry()->TimeStepToTimePoint(this->m_TimeStep);
+  m_InternalMask = SelectImageByTimePoint(m_InternalMaskImage, timePoint);
+
+  if (m_InternalMask.IsNull())
+  {
+      MITK_WARN << "Warning: time step > number of time steps in mask image, using last time step";
+      m_InternalMask = SelectImageByTimeStep(m_InternalMaskImage, m_InternalMaskImage->GetTimeSteps()-1);
+  }
 }
 
 
-mitk::Image::Pointer ImageMaskGenerator::GetMask()
+mitk::Image::ConstPointer ImageMaskGenerator::GetMask()
 {
-    if (m_internalMaskImage.IsNull())
+    if (m_InternalMaskImage.IsNull())
     {
         MITK_ERROR << "Mask Image is nullptr";
     }
     if (IsUpdateRequired())
     {
         UpdateInternalMask();
     }
 
     return m_InternalMask;
 }
 
 bool ImageMaskGenerator::IsUpdateRequired() const
 {
     unsigned long internalMaskTimeStamp = m_InternalMask->GetMTime();
-    unsigned long maskImageTimeStamp = m_internalMaskImage->GetMTime();
+    unsigned long maskImageTimeStamp = m_InternalMaskImage->GetMTime();
 
     if (maskImageTimeStamp > internalMaskTimeStamp) // inputs have changed
     {
         return true;
     }
 
     if (this->GetMTime() > maskImageTimeStamp) // input has changed
     {
         return true;
     }
 
     return false;
 }
 
 }
 
 
 
 
 
 
diff --git a/Modules/ImageStatistics/mitkImageMaskGenerator.h b/Modules/ImageStatistics/mitkImageMaskGenerator.h
index eed0de6aa6..d42e93da81 100644
--- a/Modules/ImageStatistics/mitkImageMaskGenerator.h
+++ b/Modules/ImageStatistics/mitkImageMaskGenerator.h
@@ -1,61 +1,62 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkBinaryMaskGenerator
 #define mitkBinaryMaskGenerator
 
 #include <mitkImage.h>
 #include <MitkImageStatisticsExports.h>
 #include <mitkMaskGenerator.h>
 #include <itkObject.h>
 #include <itkSmartPointer.h>
 
 namespace mitk
 {
 class MITKIMAGESTATISTICS_EXPORT ImageMaskGenerator: public MaskGenerator
 {
 public:
     /** Standard Self typedef */
     typedef ImageMaskGenerator            Self;
     typedef MaskGenerator                       Superclass;
     typedef itk::SmartPointer< Self >           Pointer;
     typedef itk::SmartPointer< const Self >     ConstPointer;
 
     /** Method for creation through the object factory. */
     itkNewMacro(Self); /** Runtime information support. */
     itkTypeMacro(BinaryImageMaskGenerator, MaskGenerator);
 
-    mitk::Image::Pointer GetMask() override;
+    mitk::Image::ConstPointer GetMask() override;
 
     void SetTimeStep(unsigned int timeStep) override;
 
-    void SetImageMask(mitk::Image::Pointer maskImage);
+    void SetImageMask(const mitk::Image* maskImage);
 
 protected:
     ImageMaskGenerator():Superclass(){
         m_InternalMaskUpdateTime = 0;
         m_InternalMask = mitk::Image::New();
     }
 
 private:
     bool IsUpdateRequired() const;
     void UpdateInternalMask();
 
-    mitk::Image::Pointer m_internalMaskImage;
+    mitk::Image::ConstPointer m_InternalMaskImage;
+    mitk::Image::ConstPointer m_InternalMask;
     unsigned long m_InternalMaskUpdateTime;
 
 };
 
 
 }
 
 #endif
diff --git a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
index 45720f16a3..6c3f8d916b 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
+++ b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
@@ -1,548 +1,550 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkImageStatisticsCalculator.h"
 #include <mitkLabelStatisticsImageFilter.h>
 #include <mitkStatisticsImageFilter.h>
 #include <mitkImage.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkImageStatisticsConstants.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkImageToItk.h>
 #include <mitkMaskUtilities.h>
 #include <mitkMinMaxImageFilterWithIndex.h>
 #include <mitkMinMaxLabelmageFilterWithIndex.h>
 #include <mitkitkMaskImageFilter.h>
 
 namespace mitk
 {
   void ImageStatisticsCalculator::SetInputImage(const mitk::Image *image)
   {
     if (image != m_Image)
     {
       m_Image = image;
       this->Modified();
     }
   }
 
   void ImageStatisticsCalculator::SetMask(mitk::MaskGenerator *mask)
   {
     if (mask != m_MaskGenerator)
     {
       m_MaskGenerator = mask;
       this->Modified();
     }
   }
 
   void ImageStatisticsCalculator::SetSecondaryMask(mitk::MaskGenerator *mask)
   {
     if (mask != m_SecondaryMaskGenerator)
     {
       m_SecondaryMaskGenerator = mask;
       this->Modified();
     }
   }
 
   void ImageStatisticsCalculator::SetNBinsForHistogramStatistics(unsigned int nBins)
   {
     if (nBins != m_nBinsForHistogramStatistics)
     {
       m_nBinsForHistogramStatistics = nBins;
       this->Modified();
       this->m_UseBinSizeOverNBins = false;
     }
     if (m_UseBinSizeOverNBins)
     {
       this->Modified();
       this->m_UseBinSizeOverNBins = false;
     }
   }
 
   unsigned int ImageStatisticsCalculator::GetNBinsForHistogramStatistics() const
   {
     return m_nBinsForHistogramStatistics;
   }
 
   void ImageStatisticsCalculator::SetBinSizeForHistogramStatistics(double binSize)
   {
     if (binSize != m_binSizeForHistogramStatistics)
     {
       m_binSizeForHistogramStatistics = binSize;
       this->Modified();
       this->m_UseBinSizeOverNBins = true;
     }
     if (!m_UseBinSizeOverNBins)
     {
       this->Modified();
       this->m_UseBinSizeOverNBins = true;
     }
   }
 
   double ImageStatisticsCalculator::GetBinSizeForHistogramStatistics() const { return m_binSizeForHistogramStatistics; }
 
   mitk::ImageStatisticsContainer* ImageStatisticsCalculator::GetStatistics(LabelIndex label)
   {
     if (m_Image.IsNull())
     {
       mitkThrow() << "no image";
     }
 
     if (!m_Image->IsInitialized())
     {
       mitkThrow() << "Image not initialized!";
     }
 
     if (IsUpdateRequired(label))
     {
       auto timeGeometry = m_Image->GetTimeGeometry();
       // always compute statistics on all timesteps
       for (unsigned int timeStep = 0; timeStep < m_Image->GetTimeSteps(); timeStep++)
       {
         if (m_MaskGenerator.IsNotNull())
         {
           m_MaskGenerator->SetTimeStep(timeStep);
           //See T25625: otherwise, the mask is not computed again after setting a different time step
           m_MaskGenerator->Modified();
           m_InternalMask = m_MaskGenerator->GetMask();
           if (m_MaskGenerator->GetReferenceImage().IsNotNull())
           {
             m_InternalImageForStatistics = m_MaskGenerator->GetReferenceImage();
           }
           else
           {
             m_InternalImageForStatistics = m_Image;
           }
         }
         else
         {
           m_InternalImageForStatistics = m_Image;
         }
 
         if (m_SecondaryMaskGenerator.IsNotNull())
         {
           m_SecondaryMaskGenerator->SetTimeStep(timeStep);
           m_SecondaryMask = m_SecondaryMaskGenerator->GetMask();
         }
 
         ImageTimeSelector::Pointer imgTimeSel = ImageTimeSelector::New();
         imgTimeSel->SetInput(m_InternalImageForStatistics);
         imgTimeSel->SetTimeNr(timeStep);
         imgTimeSel->UpdateLargestPossibleRegion();
         imgTimeSel->Update();
         m_ImageTimeSlice = imgTimeSel->GetOutput();
 
         // Calculate statistics with/without mask
         if (m_MaskGenerator.IsNull() && m_SecondaryMaskGenerator.IsNull())
         {
           // 1) calculate statistics unmasked:
           AccessByItk_2(m_ImageTimeSlice, InternalCalculateStatisticsUnmasked, timeGeometry, timeStep)
         }
         else
         {
           // 2) calculate statistics masked
           AccessByItk_2(m_ImageTimeSlice, InternalCalculateStatisticsMasked, timeGeometry, timeStep)
         }
       }
     }
 
     auto it = m_StatisticContainers.find(label);
     if (it != m_StatisticContainers.end())
     {
       return (it->second).GetPointer();
     }
     else
     {
       mitkThrow() << "unknown label";
       return nullptr;
     }
   }
 
   template <typename TPixel, unsigned int VImageDimension>
   void ImageStatisticsCalculator::InternalCalculateStatisticsUnmasked(
     typename itk::Image<TPixel, VImageDimension> *image, const TimeGeometry *timeGeometry, TimeStepType timeStep)
   {
     typedef typename itk::Image<TPixel, VImageDimension> ImageType;
     typedef typename mitk::StatisticsImageFilter<ImageType> ImageStatisticsFilterType;
     typedef typename itk::MinMaxImageFilterWithIndex<ImageType> MinMaxFilterType;
 
     // reset statistics container if exists
     ImageStatisticsContainer::Pointer statisticContainerForImage;
     LabelIndex labelNoMask = 1;
     auto it = m_StatisticContainers.find(labelNoMask);
     if (it != m_StatisticContainers.end())
     {
       statisticContainerForImage = it->second;
     }
     else
     {
       statisticContainerForImage = ImageStatisticsContainer::New();
       statisticContainerForImage->SetTimeGeometry(const_cast<mitk::TimeGeometry*>(timeGeometry));
       m_StatisticContainers.emplace(labelNoMask, statisticContainerForImage);
     }
 
     auto statObj = ImageStatisticsContainer::ImageStatisticsObject();
 
     typename ImageStatisticsFilterType::Pointer statisticsFilter = ImageStatisticsFilterType::New();
     statisticsFilter->SetInput(image);
     statisticsFilter->SetCoordinateTolerance(0.001);
     statisticsFilter->SetDirectionTolerance(0.001);
 
     // TODO: this is single threaded. Implement our own image filter that does this multi threaded
     //        typename itk::MinimumMaximumImageCalculator<ImageType>::Pointer imgMinMaxFilter =
     //        itk::MinimumMaximumImageCalculator<ImageType>::New(); imgMinMaxFilter->SetImage(image);
     //        imgMinMaxFilter->Compute();
     vnl_vector<int> minIndex, maxIndex;
 
     typename MinMaxFilterType::Pointer minMaxFilter = MinMaxFilterType::New();
     minMaxFilter->SetInput(image);
     minMaxFilter->UpdateLargestPossibleRegion();
     typename ImageType::PixelType minval = minMaxFilter->GetMin();
     typename ImageType::PixelType maxval = minMaxFilter->GetMax();
 
     typename ImageType::IndexType tmpMinIndex = minMaxFilter->GetMinIndex();
     typename ImageType::IndexType tmpMaxIndex = minMaxFilter->GetMaxIndex();
 
     //        typename ImageType::IndexType tmpMinIndex = imgMinMaxFilter->GetIndexOfMinimum();
     //        typename ImageType::IndexType tmpMaxIndex = imgMinMaxFilter->GetIndexOfMaximum();
 
     minIndex.set_size(tmpMaxIndex.GetIndexDimension());
     maxIndex.set_size(tmpMaxIndex.GetIndexDimension());
 
     for (unsigned int i = 0; i < tmpMaxIndex.GetIndexDimension(); i++)
     {
       minIndex[i] = tmpMinIndex[i];
       maxIndex[i] = tmpMaxIndex[i];
     }
 
     statObj.AddStatistic(mitk::ImageStatisticsConstants::MINIMUMPOSITION(), minIndex);
     statObj.AddStatistic(mitk::ImageStatisticsConstants::MAXIMUMPOSITION(), maxIndex);
 
     // convert m_binSize in m_nBins if necessary
     unsigned int nBinsForHistogram;
     if (m_UseBinSizeOverNBins)
     {
       nBinsForHistogram = std::max(static_cast<double>(std::ceil(maxval - minval)) / m_binSizeForHistogramStatistics,
                                    10.); // do not allow less than 10 bins
     }
     else
     {
       nBinsForHistogram = m_nBinsForHistogramStatistics;
     }
 
     statisticsFilter->SetHistogramParameters(nBinsForHistogram, minval, maxval);
 
     try
     {
       statisticsFilter->Update();
     }
     catch (const itk::ExceptionObject &e)
     {
       mitkThrow() << "Image statistics calculation failed due to following ITK Exception: \n " << e.what();
     }
 
     auto voxelVolume = GetVoxelVolume<TPixel, VImageDimension>(image);
 
     auto numberOfPixels = image->GetLargestPossibleRegion().GetNumberOfPixels();
     auto volume = static_cast<double>(numberOfPixels) * voxelVolume;
     auto variance = statisticsFilter->GetSigma() * statisticsFilter->GetSigma();
     auto rms =
       std::sqrt(std::pow(statisticsFilter->GetMean(), 2.) + statisticsFilter->GetVariance()); // variance = sigma^2
 
     statObj.AddStatistic(mitk::ImageStatisticsConstants::NUMBEROFVOXELS(),
                          static_cast<ImageStatisticsContainer::VoxelCountType>(numberOfPixels));
     statObj.AddStatistic(mitk::ImageStatisticsConstants::VOLUME(), volume);
     statObj.AddStatistic(mitk::ImageStatisticsConstants::MEAN(), statisticsFilter->GetMean());
     statObj.AddStatistic(mitk::ImageStatisticsConstants::MINIMUM(),
                          static_cast<ImageStatisticsContainer::RealType>(statisticsFilter->GetMinimum()));
     statObj.AddStatistic(mitk::ImageStatisticsConstants::MAXIMUM(),
                          static_cast<ImageStatisticsContainer::RealType>(statisticsFilter->GetMaximum()));
     statObj.AddStatistic(mitk::ImageStatisticsConstants::STANDARDDEVIATION(), statisticsFilter->GetSigma());
     statObj.AddStatistic(mitk::ImageStatisticsConstants::VARIANCE(), variance);
     statObj.AddStatistic(mitk::ImageStatisticsConstants::SKEWNESS(), statisticsFilter->GetSkewness());
     statObj.AddStatistic(mitk::ImageStatisticsConstants::KURTOSIS(), statisticsFilter->GetKurtosis());
     statObj.AddStatistic(mitk::ImageStatisticsConstants::RMS(), rms);
     statObj.AddStatistic(mitk::ImageStatisticsConstants::MPP(), statisticsFilter->GetMPP());
     statObj.AddStatistic(mitk::ImageStatisticsConstants::ENTROPY(), statisticsFilter->GetEntropy());
     statObj.AddStatistic(mitk::ImageStatisticsConstants::MEDIAN(), statisticsFilter->GetMedian());
     statObj.AddStatistic(mitk::ImageStatisticsConstants::UNIFORMITY(), statisticsFilter->GetUniformity());
     statObj.AddStatistic(mitk::ImageStatisticsConstants::UPP(), statisticsFilter->GetUPP());
     statObj.m_Histogram = statisticsFilter->GetHistogram();
     statisticContainerForImage->SetStatisticsForTimeStep(timeStep, statObj);
   }
 
   template <typename TPixel, unsigned int VImageDimension>
   double ImageStatisticsCalculator::GetVoxelVolume(typename itk::Image<TPixel, VImageDimension> *image) const
   {
     auto spacing = image->GetSpacing();
     double voxelVolume = 1.;
     for (unsigned int i = 0; i < image->GetImageDimension(); i++)
     {
       voxelVolume *= spacing[i];
     }
     return voxelVolume;
   }
 
   template <typename TPixel, unsigned int VImageDimension>
   void ImageStatisticsCalculator::InternalCalculateStatisticsMasked(typename itk::Image<TPixel, VImageDimension> *image,
                                                                     const TimeGeometry *timeGeometry,
                                                                     unsigned int timeStep)
   {
     typedef itk::Image<TPixel, VImageDimension> ImageType;
     typedef itk::Image<MaskPixelType, VImageDimension> MaskType;
     typedef typename MaskType::PixelType LabelPixelType;
     typedef LabelStatisticsImageFilter<ImageType> ImageStatisticsFilterType;
     typedef MaskUtilities<TPixel, VImageDimension> MaskUtilType;
     typedef typename itk::MinMaxLabelImageFilterWithIndex<ImageType, MaskType> MinMaxLabelFilterType;
 
     // workaround: if m_SecondaryMaskGenerator ist not null but m_MaskGenerator is! (this is the case if we request a
     // 'ignore zuero valued pixels' mask in the gui but do not define a primary mask)
     bool swapMasks = false;
     if (m_SecondaryMask.IsNotNull() && m_InternalMask.IsNull())
     {
       m_InternalMask = m_SecondaryMask;
       m_SecondaryMask = nullptr;
       swapMasks = true;
     }
 
     // maskImage has to have the same dimension as image
-    typename MaskType::Pointer maskImage = MaskType::New();
+    typename MaskType::ConstPointer maskImage = MaskType::New();
     try
     {
       // try to access the pixel values directly (no copying or casting). Only works if mask pixels are of pixelType
       // unsigned short
       maskImage = ImageToItkImage<MaskPixelType, VImageDimension>(m_InternalMask);
     }
     catch (const itk::ExceptionObject &)
 
     {
+      typename MaskType::Pointer noneConstMaskImage; //needed to work arround the fact that CastToItkImage currently does not support const itk images.
       // if the pixel type of the mask is not short, then we have to make a copy of m_InternalMask (and cast the values)
-      CastToItkImage(m_InternalMask, maskImage);
+      CastToItkImage(m_InternalMask, noneConstMaskImage);
+      maskImage = noneConstMaskImage;
     }
 
     // if we have a secondary mask (say a ignoreZeroPixelMask) we need to combine the masks (corresponds to AND)
     if (m_SecondaryMask.IsNotNull())
     {
       // dirty workaround for a bug when pf mask + any other mask is used in conjunction. We need a proper fix for this
       // (Fabian Isensee is responsible and probably working on it!)
       if (m_InternalMask->GetDimension() == 2 &&
           (m_SecondaryMask->GetDimension() == 3 || m_SecondaryMask->GetDimension() == 4))
       {
         mitk::Image::ConstPointer old_img = m_SecondaryMaskGenerator->GetReferenceImage();
         m_SecondaryMaskGenerator->SetInputImage(m_MaskGenerator->GetReferenceImage());
         m_SecondaryMask = m_SecondaryMaskGenerator->GetMask();
         m_SecondaryMaskGenerator->SetInputImage(old_img);
       }
-      typename MaskType::Pointer secondaryMaskImage = MaskType::New();
+      typename MaskType::ConstPointer secondaryMaskImage = MaskType::New();
       secondaryMaskImage = ImageToItkImage<MaskPixelType, VImageDimension>(m_SecondaryMask);
 
       // secondary mask should be a ignore zero value pixel mask derived from image. it has to be cropped to the mask
       // region (which may be planar or simply smaller)
       typename MaskUtilities<MaskPixelType, VImageDimension>::Pointer secondaryMaskMaskUtil =
         MaskUtilities<MaskPixelType, VImageDimension>::New();
       secondaryMaskMaskUtil->SetImage(secondaryMaskImage.GetPointer());
       secondaryMaskMaskUtil->SetMask(maskImage.GetPointer());
-      typename MaskType::Pointer adaptedSecondaryMaskImage = secondaryMaskMaskUtil->ExtractMaskImageRegion();
+      typename MaskType::ConstPointer adaptedSecondaryMaskImage = secondaryMaskMaskUtil->ExtractMaskImageRegion();
 
       typename itk::MaskImageFilter2<MaskType, MaskType, MaskType>::Pointer maskFilter =
         itk::MaskImageFilter2<MaskType, MaskType, MaskType>::New();
       maskFilter->SetInput1(maskImage);
       maskFilter->SetInput2(adaptedSecondaryMaskImage);
       maskFilter->SetMaskingValue(
         1); // all pixels of maskImage where secondaryMaskImage==1 will be kept, all the others are set to 0
       maskFilter->UpdateLargestPossibleRegion();
       maskImage = maskFilter->GetOutput();
     }
 
     typename MaskUtilType::Pointer maskUtil = MaskUtilType::New();
     maskUtil->SetImage(image);
     maskUtil->SetMask(maskImage.GetPointer());
 
     // if mask is smaller than image, extract the image region where the mask is
-    typename ImageType::Pointer adaptedImage = ImageType::New();
+    typename ImageType::ConstPointer adaptedImage = ImageType::New();
 
     adaptedImage = maskUtil->ExtractMaskImageRegion(); // this also checks mask sanity
 
     // find min, max, minindex and maxindex
     typename MinMaxLabelFilterType::Pointer minMaxFilter = MinMaxLabelFilterType::New();
     minMaxFilter->SetInput(adaptedImage);
     minMaxFilter->SetLabelInput(maskImage);
     minMaxFilter->UpdateLargestPossibleRegion();
 
     // set histogram parameters for each label individually (min/max may be different for each label)
     typedef typename std::unordered_map<LabelPixelType, ScalarType> MapType;
 
     std::vector<LabelPixelType> relevantLabels = minMaxFilter->GetRelevantLabels();
     MapType minVals;
     MapType maxVals;
     std::unordered_map<LabelPixelType, unsigned int> nBins;
 
     for (LabelPixelType label : relevantLabels)
     {
       minVals[label] = static_cast<ScalarType>(minMaxFilter->GetMin(label));
       maxVals[label] = static_cast<ScalarType>(minMaxFilter->GetMax(label));
 
       unsigned int nBinsForHistogram;
       if (m_UseBinSizeOverNBins)
       {
         nBinsForHistogram =
           std::max(static_cast<double>(std::ceil(minMaxFilter->GetMax(label) - minMaxFilter->GetMin(label))) /
                      m_binSizeForHistogramStatistics,
                    10.); // do not allow less than 10 bins
       }
       else
       {
         nBinsForHistogram = m_nBinsForHistogramStatistics;
       }
 
       nBins[label] = nBinsForHistogram;
     }
 
     typename ImageStatisticsFilterType::Pointer imageStatisticsFilter = ImageStatisticsFilterType::New();
     imageStatisticsFilter->SetDirectionTolerance(0.001);
     imageStatisticsFilter->SetCoordinateTolerance(0.001);
     imageStatisticsFilter->SetInput(adaptedImage);
     imageStatisticsFilter->SetLabelInput(maskImage);
     imageStatisticsFilter->SetHistogramParameters(nBins, minVals, maxVals);
     imageStatisticsFilter->Update();
 
     auto labels = imageStatisticsFilter->GetValidLabelValues();
     auto it = labels.begin();
 
     while (it != labels.end())
     {
       ImageStatisticsContainer::Pointer statisticContainerForLabelImage;
       auto labelIt = m_StatisticContainers.find(*it);
       // reset if statisticContainer already exist
       if (labelIt != m_StatisticContainers.end())
       {
         statisticContainerForLabelImage = labelIt->second;
       }
       // create new statisticContainer
       else
       {
         statisticContainerForLabelImage = ImageStatisticsContainer::New();
         statisticContainerForLabelImage->SetTimeGeometry(const_cast<mitk::TimeGeometry*>(timeGeometry));
         // link label (*it) to statisticContainer
         m_StatisticContainers.emplace(*it, statisticContainerForLabelImage);
       }
 
       ImageStatisticsContainer::ImageStatisticsObject statObj;
 
       // find min, max, minindex and maxindex
       // make sure to only look in the masked region, use a masker for this
 
       vnl_vector<int> minIndex, maxIndex;
       mitk::Point3D worldCoordinateMin;
       mitk::Point3D worldCoordinateMax;
       mitk::Point3D indexCoordinateMin;
       mitk::Point3D indexCoordinateMax;
       m_InternalImageForStatistics->GetGeometry()->IndexToWorld(minMaxFilter->GetMinIndex(*it), worldCoordinateMin);
       m_InternalImageForStatistics->GetGeometry()->IndexToWorld(minMaxFilter->GetMaxIndex(*it), worldCoordinateMax);
       m_Image->GetGeometry()->WorldToIndex(worldCoordinateMin, indexCoordinateMin);
       m_Image->GetGeometry()->WorldToIndex(worldCoordinateMax, indexCoordinateMax);
 
       minIndex.set_size(3);
       maxIndex.set_size(3);
 
       // for (unsigned int i=0; i < tmpMaxIndex.GetIndexDimension(); i++)
       for (unsigned int i = 0; i < 3; i++)
       {
         minIndex[i] = indexCoordinateMin[i];
         maxIndex[i] = indexCoordinateMax[i];
       }
 
       statObj.AddStatistic(mitk::ImageStatisticsConstants::MINIMUMPOSITION(), minIndex);
       statObj.AddStatistic(mitk::ImageStatisticsConstants::MAXIMUMPOSITION(), maxIndex);
 
       auto voxelVolume = GetVoxelVolume<TPixel, VImageDimension>(image);
       auto numberOfVoxels =
         static_cast<unsigned long>(imageStatisticsFilter->GetCount(*it));
       auto volume = static_cast<double>(numberOfVoxels) * voxelVolume;
       auto rms = std::sqrt(std::pow(imageStatisticsFilter->GetMean(*it), 2.) +
                            imageStatisticsFilter->GetVariance(*it)); // variance = sigma^2
       auto variance = imageStatisticsFilter->GetSigma(*it) * imageStatisticsFilter->GetSigma(*it);
 
       statObj.AddStatistic(mitk::ImageStatisticsConstants::NUMBEROFVOXELS(), numberOfVoxels);
       statObj.AddStatistic(mitk::ImageStatisticsConstants::VOLUME(), volume);
       statObj.AddStatistic(mitk::ImageStatisticsConstants::MEAN(), imageStatisticsFilter->GetMean(*it));
       statObj.AddStatistic(mitk::ImageStatisticsConstants::MINIMUM(),
         static_cast<ImageStatisticsContainer::RealType>(imageStatisticsFilter->GetMinimum(*it)));
       statObj.AddStatistic(mitk::ImageStatisticsConstants::MAXIMUM(),
         static_cast<ImageStatisticsContainer::RealType>(imageStatisticsFilter->GetMaximum(*it)));
       statObj.AddStatistic(mitk::ImageStatisticsConstants::STANDARDDEVIATION(), imageStatisticsFilter->GetSigma(*it));
       statObj.AddStatistic(mitk::ImageStatisticsConstants::VARIANCE(), variance);
       statObj.AddStatistic(mitk::ImageStatisticsConstants::SKEWNESS(), imageStatisticsFilter->GetSkewness(*it));
       statObj.AddStatistic(mitk::ImageStatisticsConstants::KURTOSIS(), imageStatisticsFilter->GetKurtosis(*it));
       statObj.AddStatistic(mitk::ImageStatisticsConstants::RMS(), rms);
       statObj.AddStatistic(mitk::ImageStatisticsConstants::MPP(), imageStatisticsFilter->GetMPP(*it));
       statObj.AddStatistic(mitk::ImageStatisticsConstants::ENTROPY(), imageStatisticsFilter->GetEntropy(*it));
       statObj.AddStatistic(mitk::ImageStatisticsConstants::MEDIAN(), imageStatisticsFilter->GetMedian(*it));
       statObj.AddStatistic(mitk::ImageStatisticsConstants::UNIFORMITY(), imageStatisticsFilter->GetUniformity(*it));
       statObj.AddStatistic(mitk::ImageStatisticsConstants::UPP(), imageStatisticsFilter->GetUPP(*it));
       statObj.m_Histogram = imageStatisticsFilter->GetHistogram(*it);
       statisticContainerForLabelImage->SetStatisticsForTimeStep(timeStep, statObj);
       ++it;
     }
 
     // swap maskGenerators back
     if (swapMasks)
     {
       m_SecondaryMask = m_InternalMask;
       m_InternalMask = nullptr;
     }
   }
 
   bool ImageStatisticsCalculator::IsUpdateRequired(LabelIndex label) const
   {
     unsigned long thisClassTimeStamp = this->GetMTime();
     unsigned long inputImageTimeStamp = m_Image->GetMTime();
 
     auto it = m_StatisticContainers.find(label);
     if (it == m_StatisticContainers.end())
     {
       return true;
     }
 
     unsigned long statisticsTimeStamp = it->second->GetMTime();
 
     if (thisClassTimeStamp > statisticsTimeStamp) // inputs have changed
     {
       return true;
     }
 
     if (inputImageTimeStamp > statisticsTimeStamp) // image has changed
     {
       return true;
     }
 
     if (m_MaskGenerator.IsNotNull())
     {
       unsigned long maskGeneratorTimeStamp = m_MaskGenerator->GetMTime();
       if (maskGeneratorTimeStamp > statisticsTimeStamp) // there is a mask generator and it has changed
       {
         return true;
       }
     }
 
     if (m_SecondaryMaskGenerator.IsNotNull())
     {
       unsigned long maskGeneratorTimeStamp = m_SecondaryMaskGenerator->GetMTime();
       if (maskGeneratorTimeStamp > statisticsTimeStamp) // there is a secondary mask generator and it has changed
       {
         return true;
       }
     }
 
     return false;
   }
 } // namespace mitk
diff --git a/Modules/ImageStatistics/mitkImageStatisticsCalculator.h b/Modules/ImageStatistics/mitkImageStatisticsCalculator.h
index b3489707c5..459aa688e2 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsCalculator.h
+++ b/Modules/ImageStatistics/mitkImageStatisticsCalculator.h
@@ -1,120 +1,120 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKIMAGESTATISTICSCALCULATOR
 #define MITKIMAGESTATISTICSCALCULATOR
 
 #include <MitkImageStatisticsExports.h>
 #include <mitkImage.h>
 #include <mitkMaskGenerator.h>
 #include <mitkImageStatisticsContainer.h>
 
 namespace mitk
 {
     class MITKIMAGESTATISTICS_EXPORT ImageStatisticsCalculator: public itk::Object
     {
     public:
         /** Standard Self typedef */
         typedef ImageStatisticsCalculator        Self;
         typedef itk::Object                         Superclass;
         typedef itk::SmartPointer< Self >           Pointer;
         typedef itk::SmartPointer< const Self >     ConstPointer;
 
         /** Method for creation through the object factory. */
         itkNewMacro(Self); /** Runtime information support. */
         itkTypeMacro(ImageStatisticsCalculator_v2, itk::Object);
 
         typedef double statisticsValueType;
         typedef std::map<std::string, statisticsValueType> statisticsMapType;
         typedef itk::Statistics::Histogram<double> HistogramType;
         typedef unsigned short MaskPixelType;
         using LabelIndex = ImageStatisticsContainer::LabelIndex;
 
         /**Documentation
         @brief Set the image for which the statistics are to be computed.*/
         void SetInputImage(const mitk::Image* image);
 
         /**Documentation
         @brief Set the mask generator that creates the mask which is to be used to calculate statistics. If no more mask is desired simply set @param mask to nullptr*/
         void SetMask(mitk::MaskGenerator* mask);
 
         /**Documentation
         @brief Set this if more than one mask should be applied (for instance if a IgnorePixelValueMask were to be used alongside with a segmentation).
         Both masks are combined using pixel wise AND operation. The secondary mask does not have to be the same size than the primary but they need to have some overlap*/
         void SetSecondaryMask(mitk::MaskGenerator* mask);
 
         /**Documentation
         @brief Set number of bins to be used for histogram statistics. If Bin size is set after number of bins, bin size will be used instead!*/
         void SetNBinsForHistogramStatistics(unsigned int nBins);
 
         /**Documentation
         @brief Retrieve the number of bins used for histogram statistics. Careful: The return value does not indicate whether NBins or BinSize is used.
         That solely depends on which parameter has been set last.*/
         unsigned int GetNBinsForHistogramStatistics() const;
 
         /**Documentation
         @brief Set bin size to be used for histogram statistics. If nbins is set after bin size, nbins will be used instead!*/
         void SetBinSizeForHistogramStatistics(double binSize);
 
         /**Documentation
         @brief Retrieve the bin size for histogram statistics. Careful: The return value does not indicate whether NBins or BinSize is used.
         That solely depends on which parameter has been set last.*/
         double GetBinSizeForHistogramStatistics() const;
 
         /**Documentation
         @brief Returns the statistics for label @a label. If these requested statistics are not computed yet the computation is done as well.
         For performance reasons, statistics for all labels in the image are computed at once.
          */
         ImageStatisticsContainer* GetStatistics(LabelIndex label=1);
 
     protected:
         ImageStatisticsCalculator(){
             m_nBinsForHistogramStatistics = 100;
             m_binSizeForHistogramStatistics = 10;
             m_UseBinSizeOverNBins = false;
         };
 
 
     private:
         //Calculates statistics for each timestep for image
         template < typename TPixel, unsigned int VImageDimension > void InternalCalculateStatisticsUnmasked(
                 typename itk::Image< TPixel, VImageDimension >* image, const TimeGeometry* timeGeometry, TimeStepType timeStep);
 
         template < typename TPixel, unsigned int VImageDimension > void InternalCalculateStatisticsMasked(
                 typename itk::Image< TPixel, VImageDimension >* image, const TimeGeometry* timeGeometry,
                 unsigned int timeStep);
 
         template < typename TPixel, unsigned int VImageDimension >
         double GetVoxelVolume(typename itk::Image<TPixel, VImageDimension>* image) const;
 
         bool IsUpdateRequired(LabelIndex label) const;
 
         mitk::Image::ConstPointer m_Image;
         mitk::Image::Pointer m_ImageTimeSlice;
         mitk::Image::ConstPointer m_InternalImageForStatistics;
 
         mitk::MaskGenerator::Pointer m_MaskGenerator;
-        mitk::Image::Pointer m_InternalMask;
+        mitk::Image::ConstPointer m_InternalMask;
 
         mitk::MaskGenerator::Pointer m_SecondaryMaskGenerator;
-        mitk::Image::Pointer m_SecondaryMask;
+        mitk::Image::ConstPointer m_SecondaryMask;
 
         unsigned int m_nBinsForHistogramStatistics;
         double m_binSizeForHistogramStatistics;
         bool m_UseBinSizeOverNBins;
 
         std::map<LabelIndex,ImageStatisticsContainer::Pointer> m_StatisticContainers;
     };
 
 }
 #endif // MITKIMAGESTATISTICSCALCULATOR
 
diff --git a/Modules/ImageStatistics/mitkMaskGenerator.cpp b/Modules/ImageStatistics/mitkMaskGenerator.cpp
index af8b4a812b..0e29bbb2e4 100644
--- a/Modules/ImageStatistics/mitkMaskGenerator.cpp
+++ b/Modules/ImageStatistics/mitkMaskGenerator.cpp
@@ -1,64 +1,45 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkMaskGenerator.h>
 
 namespace mitk
 {
 
 MaskGenerator::MaskGenerator():
     m_TimeStep(0)
 {
     m_inputImage = nullptr;
 }
 
-mitk::Image::Pointer MaskGenerator::GetMask()
-{
-  return mitk::Image::New();
-}
-
-
-//typename itk::Region<3>::Pointer MaskGenerator::GetImageRegionOfMask(Image::Pointer image)
-//{
-//    if (m_InternalMask.IsNull() || m_Modified)
-//    {
-//        MITK_ERROR << "Update MaskGenerator first!";
-//    }
-
-//    mitk::BaseGeometry::Pointer imageGeometry = image->GetGeometry();
-//    mitk::BaseGeometry::Pointer maskGeometry = m_InternalMask->GetGeometry();
-
-
-//}
-
 void MaskGenerator::SetTimeStep(unsigned int timeStep)
 {
     if (timeStep != m_TimeStep)
     {
         m_TimeStep = timeStep;
     }
 }
 
 void MaskGenerator::SetInputImage(mitk::Image::ConstPointer inputImg)
 {
     if (inputImg != m_inputImage)
     {
         m_inputImage = inputImg;
         this->Modified();
     }
 }
 
 mitk::Image::ConstPointer MaskGenerator::GetReferenceImage()
 {
     return m_inputImage;
 }
 }
diff --git a/Modules/ImageStatistics/mitkMaskGenerator.h b/Modules/ImageStatistics/mitkMaskGenerator.h
index 76d976c777..adbafda62c 100644
--- a/Modules/ImageStatistics/mitkMaskGenerator.h
+++ b/Modules/ImageStatistics/mitkMaskGenerator.h
@@ -1,76 +1,74 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKMASKGENERATOR
 #define MITKMASKGENERATOR
 
 #include <MitkImageStatisticsExports.h>
 #include <mitkImage.h>
 #include <itkRegion.h>
 #include <itkObject.h>
 #include <itkSmartPointer.h>
 
 namespace mitk
 {
 /**
 * \class MaskGenerator
 * \brief Base Class for all Mask Generators. Mask generators are classes that provide functionality for the
 * creation of binary (or unsigned short) masks that can be applied to an image. See dervied classes for more
 * information.
 */
 class MITKIMAGESTATISTICS_EXPORT MaskGenerator: public itk::Object
 {
 public:
     /** Standard Self typedef */
     typedef MaskGenerator                       Self;
     typedef itk::Object                         Superclass;
     typedef itk::SmartPointer< Self >           Pointer;
     typedef itk::SmartPointer< const Self >     ConstPointer;
 
     /** Method for creation through the object factory. */
-    itkNewMacro(Self); /** Runtime information support. */
     itkTypeMacro(MaskGenerator, itk::Object);
 
     //~MaskGenerator();
 
     /**
      * @brief GetMask must be overridden by derived classes.
      * @return mitk::Image::Pointer of generated mask
      */
-    virtual mitk::Image::Pointer GetMask();
+    virtual mitk::Image::ConstPointer GetMask() = 0;
 
     /**
      * @brief GetReferenceImage per default returns the inputImage (as set by SetInputImage). If no input image is set it will return a nullptr.
      */
     virtual mitk::Image::ConstPointer GetReferenceImage();
 
     /**
      * @brief SetInputImage is used to set the input image to the mask generator. Some subclasses require an input image, others don't. See the documentation of the specific Mask Generator for more information.
      */
     void SetInputImage(mitk::Image::ConstPointer inputImg);
 
     virtual void SetTimeStep(unsigned int timeStep);
 
 protected:
     MaskGenerator();
 
     unsigned int m_TimeStep;
-    mitk::Image::Pointer m_InternalMask;
     mitk::Image::ConstPointer m_inputImage;
 
 private:
 
 };
 }
 
 #endif // MITKMASKGENERATOR
 
diff --git a/Modules/ImageStatistics/mitkMaskUtilities.h b/Modules/ImageStatistics/mitkMaskUtilities.h
index ec0ff30f99..4ec2b2631e 100644
--- a/Modules/ImageStatistics/mitkMaskUtilities.h
+++ b/Modules/ImageStatistics/mitkMaskUtilities.h
@@ -1,88 +1,88 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKMASKUTIL
 #define MITKMASKUTIL
 
 #include <MitkImageStatisticsExports.h>
 #include <mitkImage.h>
 #include <mitkNodePredicateGeometry.h>
 #include <itkImage.h>
 
 namespace mitk
 {
 /**
  * @brief Utility class for mask operations. It checks whether an image and a mask are compatible (spacing, orientation, etc...)
  * and it can also crop an image to the LargestPossibleRegion of the Mask
  */
 template <class TPixel, unsigned int VImageDimension>
 class MaskUtilities: public itk::Object
     {
     public:
         /** Standard Self typedef */
         typedef MaskUtilities                       Self;
         typedef itk::Object                         Superclass;
         typedef itk::SmartPointer< Self >           Pointer;
         typedef itk::SmartPointer< const Self >     ConstPointer;
 
         /** Method for creation through the object factory. */
         itkNewMacro(Self); /** Runtime information support. */
         itkTypeMacro(MaskUtilities, itk::Object);
 
         typedef itk::Image<TPixel, VImageDimension> ImageType;
         typedef itk::Image<unsigned short, VImageDimension> MaskType;
 
         /**
          * @brief Set image
          */
-        void SetImage(ImageType* image);
+        void SetImage(const ImageType* image);
 
         /**
          * @brief Set mask
          */
-        void SetMask(MaskType* mask);
+        void SetMask(const MaskType* mask);
 
         /**
          * @brief Checks whether mask and image are compatible for joint access (as via iterators).
          * Spacing and direction must be the same between the two and they must be aligned. Also, the mask must be completely inside the image
          */
         bool CheckMaskSanity();
 
         /**
          * @brief Crops the image to the LargestPossibleRegion of the mask
          */
-        typename itk::Image<TPixel, VImageDimension>::Pointer ExtractMaskImageRegion();
+        typename ImageType::ConstPointer ExtractMaskImageRegion();
 
     protected:
         MaskUtilities(): m_Image(nullptr), m_Mask(nullptr){}
 
         ~MaskUtilities() override{}
 
     private:
-        itk::Image<TPixel, VImageDimension>* m_Image;
-        itk::Image<unsigned short, VImageDimension>* m_Mask;
+        const ImageType* m_Image;
+        const MaskType* m_Mask;
     };
 
 /** Tolerance used to check if the mask and input image are compatible for
  * coordinate aspects (orgin, size, grid alignment).*/
 constexpr double MASK_SUITABILITY_TOLERANCE_COORDINATE = NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_COORDINATE_PRECISION;
 /** Tolerance used to check if the mask and input image are compatible for
  * direction aspects (orientation of mask and image).*/
 constexpr double MASK_SUITABILITY_TOLERANCE_DIRECTION = NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_DIRECTION_PRECISION;
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include <mitkMaskUtilities.tpp>
 #endif
 
 #endif
diff --git a/Modules/ImageStatistics/mitkMaskUtilities.tpp b/Modules/ImageStatistics/mitkMaskUtilities.tpp
index 25a8b4a2ff..f1d52ea2aa 100644
--- a/Modules/ImageStatistics/mitkMaskUtilities.tpp
+++ b/Modules/ImageStatistics/mitkMaskUtilities.tpp
@@ -1,196 +1,194 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKMASKUTIL_TPP
 #define MITKMASKUTIL_TPP
 
 #include <mitkMaskUtilities.h>
 #include <mitkImageAccessByItk.h>
 #include <itkExtractImageFilter.h>
 #include <itkChangeInformationImageFilter.h>
 #include <mitkITKImageImport.h>
 
 namespace mitk
 {
     template <class TPixel, unsigned int VImageDimension>
-    void MaskUtilities<TPixel, VImageDimension>::SetImage(ImageType* image)
+    void MaskUtilities<TPixel, VImageDimension>::SetImage(const ImageType* image)
     {
         if (image != m_Image)
         {
             m_Image = image;
         }
     }
 
     template <class TPixel, unsigned int VImageDimension>
-    void MaskUtilities<TPixel, VImageDimension>::SetMask(MaskType* mask)
+    void MaskUtilities<TPixel, VImageDimension>::SetMask(const MaskType* mask)
     {
         if (mask != m_Mask)
         {
             m_Mask = mask;
         }
     }
 
     template <class TPixel, unsigned int VImageDimension>
     bool MaskUtilities<TPixel, VImageDimension>::CheckMaskSanity()
         {
             if (m_Mask==nullptr || m_Image==nullptr)
             {
                 MITK_ERROR << "Set an image and a mask first";
             }
 
             typedef itk::Image< TPixel, VImageDimension > ImageType;
             typedef typename ImageType::PointType PointType;
             typedef typename ImageType::DirectionType DirectionType;
 
             bool maskSanity = true;
 
 
             if (m_Mask==nullptr)
             {
                 MITK_ERROR << "Something went wrong when casting the mitk mask image to an itk mask image. Do the mask and the input image have the same dimension?";
                 // note to self: We could try to convert say a 2d mask to a 3d mask if the image is 3d. (mask and image dimension have to match.)
             }
             // check direction
             DirectionType imageDirection = m_Image->GetDirection();
             DirectionType maskDirection = m_Mask->GetDirection();
             for(unsigned int i = 0; i < imageDirection.ColumnDimensions; ++i )
             {
               for(unsigned int j = 0; j < imageDirection.ColumnDimensions; ++j )
               {
                 double differenceDirection = imageDirection[i][j] - maskDirection[i][j];
                 if (fabs(differenceDirection) > MASK_SUITABILITY_TOLERANCE_DIRECTION)
                 {
                   maskSanity = false;
                   MITK_INFO << "Mask needs to have same direction as image! (Image direction: " << imageDirection << "; Mask direction: " << maskDirection << ")";
                 }
               }
             }
 
             // check spacing
             PointType imageSpacing = m_Image->GetSpacing();
             PointType maskSpacing = m_Mask->GetSpacing();
             for (unsigned int i = 0; i < VImageDimension; i++)
             {
                 if ( fabs( maskSpacing[i] - imageSpacing[i] ) > MASK_SUITABILITY_TOLERANCE_COORDINATE )
                 {
                     maskSanity = false;
                     MITK_INFO << "Spacing of mask and image is not equal. Mask: " << maskSpacing << " image: " << imageSpacing;
                 }
             }
 
             // check alignment
             // Make sure that the voxels of mask and image are correctly "aligned", i.e., voxel boundaries are the same in both images
             PointType imageOrigin = m_Image->GetOrigin();
             PointType maskOrigin = m_Mask->GetOrigin();
 
             typedef itk::ContinuousIndex<double, VImageDimension> ContinousIndexType;
             ContinousIndexType maskOriginContinousIndex, imageOriginContinousIndex;
 
             m_Image->TransformPhysicalPointToContinuousIndex(maskOrigin, maskOriginContinousIndex);
             m_Image->TransformPhysicalPointToContinuousIndex(imageOrigin, imageOriginContinousIndex);
 
             for ( unsigned int i = 0; i < ImageType::ImageDimension; ++i )
             {
               double misalignment = maskOriginContinousIndex[i] - floor( maskOriginContinousIndex[i] + 0.5 );
               // misalignment must be a multiple (int) of spacing in that direction
               if (  fmod(misalignment,imageSpacing[i])  > MASK_SUITABILITY_TOLERANCE_COORDINATE)
               {
                   maskSanity = false;
                   MITK_INFO << "Pixels/voxels of mask and image are not sufficiently aligned! (Misalignment: " << fmod(misalignment,imageSpacing[i]) << ")";
               }
             }
 
             // mask must be completely inside image region
             // Make sure that mask region is contained within image region
             if ( m_Mask!=nullptr &&
               !m_Image->GetLargestPossibleRegion().IsInside( m_Mask->GetLargestPossibleRegion() ) )
             {
               maskSanity = false;
               MITK_INFO << "Mask region needs to be inside of image region! (Image region: "
                 << m_Image->GetLargestPossibleRegion() << "; Mask region: " << m_Mask->GetLargestPossibleRegion() << ")";
             }
             return maskSanity;
         }
 
     template <class TPixel, unsigned int VImageDimension>
-    typename itk::Image<TPixel, VImageDimension>::Pointer MaskUtilities<TPixel, VImageDimension>::ExtractMaskImageRegion()
+    typename MaskUtilities<TPixel, VImageDimension >::ImageType::ConstPointer MaskUtilities<TPixel, VImageDimension>::ExtractMaskImageRegion()
     {
         if (m_Mask==nullptr || m_Image==nullptr)
         {
             MITK_ERROR << "Set an image and a mask first";
         }
 
         bool maskSanity = CheckMaskSanity();
 
         if (!maskSanity)
         {
             MITK_ERROR << "Mask and image are not compatible";
         }
 
-        typedef itk::Image< TPixel, VImageDimension > ImageType;
-        typedef itk::Image< unsigned short, VImageDimension > MaskType;
         typedef itk::ExtractImageFilter< ImageType, ImageType > ExtractImageFilterType;
 
         typename ImageType::SizeType imageSize = m_Image->GetBufferedRegion().GetSize();
         typename ImageType::SizeType maskSize = m_Mask->GetBufferedRegion().GetSize();
 
-        typename itk::Image<TPixel, VImageDimension>::Pointer extractedImg = itk::Image<TPixel, VImageDimension>::New();
+        typename itk::Image<TPixel, VImageDimension>::ConstPointer resultImg;
 
         bool maskSmallerImage = false;
         for ( unsigned int i = 0; i < ImageType::ImageDimension; ++i )
         {
           if ( maskSize[i] < imageSize[i] )
           {
             maskSmallerImage = true;
           }
         }
 
         if ( maskSmallerImage )
         {
           typename ExtractImageFilterType::Pointer extractImageFilter = ExtractImageFilterType::New();
           typename MaskType::PointType maskOrigin = m_Mask->GetOrigin();
           typename ImageType::PointType imageOrigin = m_Image->GetOrigin();
           typename MaskType::SpacingType maskSpacing = m_Mask->GetSpacing();
           typename ImageType::RegionType extractionRegion;
           typename ImageType::IndexType extractionRegionIndex;
 
 
           for (unsigned int i=0; i < maskOrigin.GetPointDimension(); i++)
           {
               extractionRegionIndex[i] = (maskOrigin[i] - imageOrigin[i]) / maskSpacing[i];
           }
 
           extractionRegion.SetIndex(extractionRegionIndex);
           extractionRegion.SetSize(m_Mask->GetLargestPossibleRegion().GetSize());
 
           extractImageFilter->SetInput( m_Image );
           extractImageFilter->SetExtractionRegion( extractionRegion );
           extractImageFilter->SetCoordinateTolerance(MASK_SUITABILITY_TOLERANCE_COORDINATE);
           extractImageFilter->SetDirectionTolerance(MASK_SUITABILITY_TOLERANCE_DIRECTION);
           extractImageFilter->Update();
-          extractedImg = extractImageFilter->GetOutput();
+          auto extractedImg = extractImageFilter->GetOutput();
           extractedImg->SetOrigin(m_Mask->GetOrigin());
           extractedImg->SetLargestPossibleRegion(m_Mask->GetLargestPossibleRegion());
           extractedImg->SetBufferedRegion(m_Mask->GetBufferedRegion());
-
+          resultImg = extractedImg;
         }
         else
         {
-          extractedImg = m_Image;
+          resultImg = m_Image;
         }
 
-        return extractedImg;
+        return resultImg;
     }
 
 }
 
 #endif
diff --git a/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.cpp b/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.cpp
index 6acffbfdf4..c44d2100d6 100644
--- a/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.cpp
+++ b/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.cpp
@@ -1,512 +1,512 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkPlanarFigureMaskGenerator.h>
 #include <mitkBaseGeometry.h>
 #include <mitkITKImageImport.h>
 #include "mitkImageAccessByItk.h"
 #include <mitkExtractImageFilter.h>
 #include <mitkConvert2Dto3DImageFilter.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkIOUtil.h>
 
 #include <itkCastImageFilter.h>
 #include <itkVTKImageExport.h>
 #include <itkVTKImageImport.h>
 #include <itkImageDuplicator.h>
 #include <itkMacro.h>
 #include <itkLineIterator.h>
 
 #include <vtkPoints.h>
 #include <vtkImageStencil.h>
 #include <vtkImageImport.h>
 #include <vtkImageExport.h>
 #include <vtkLassoStencilSource.h>
 #include <vtkSmartPointer.h>
 
 
 
 namespace mitk
 {
 
-void PlanarFigureMaskGenerator::SetPlanarFigure(mitk::PlanarFigure::Pointer planarFigure)
+void PlanarFigureMaskGenerator::SetPlanarFigure(mitk::PlanarFigure* planarFigure)
 {
-    if ( planarFigure.IsNull() )
+    if (nullptr == planarFigure )
     {
       throw std::runtime_error( "Error: planar figure empty!" );
     }
 
     const PlaneGeometry *planarFigurePlaneGeometry = planarFigure->GetPlaneGeometry();
     if ( planarFigurePlaneGeometry == nullptr )
     {
       throw std::runtime_error( "Planar-Figure not yet initialized!" );
     }
 
     const auto *planarFigureGeometry =
       dynamic_cast< const PlaneGeometry * >( planarFigurePlaneGeometry );
     if ( planarFigureGeometry == nullptr )
     {
       throw std::runtime_error( "Non-planar planar figures not supported!" );
     }
 
     if (planarFigure != m_PlanarFigure)
     {
         this->Modified();
         m_PlanarFigure = planarFigure;
     }
 
 }
 
 mitk::Image::ConstPointer PlanarFigureMaskGenerator::GetReferenceImage()
 {
     if (IsUpdateRequired())
     {
         this->CalculateMask();
     }
     return m_ReferenceImage;
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void PlanarFigureMaskGenerator::InternalCalculateMaskFromPlanarFigure(
   const itk::Image< TPixel, VImageDimension > *image, unsigned int axis )
 {
   typedef itk::Image< unsigned short, 2 > MaskImage2DType;
 
   typename MaskImage2DType::Pointer maskImage = MaskImage2DType::New();
   maskImage->SetOrigin(image->GetOrigin());
   maskImage->SetSpacing(image->GetSpacing());
   maskImage->SetLargestPossibleRegion(image->GetLargestPossibleRegion());
   maskImage->SetBufferedRegion(image->GetBufferedRegion());
   maskImage->SetDirection(image->GetDirection());
   maskImage->SetNumberOfComponentsPerPixel(image->GetNumberOfComponentsPerPixel());
   maskImage->Allocate();
   maskImage->FillBuffer(1);
 
   // all PolylinePoints of the PlanarFigure are stored in a vtkPoints object.
   // These points are used by the vtkLassoStencilSource to create
   // a vtkImageStencil.
   const mitk::PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
   const typename PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
   const mitk::BaseGeometry *imageGeometry3D = m_inputImage->GetGeometry( 0 );
   // If there is a second poly line in a closed planar figure, treat it as a hole.
   PlanarFigure::PolyLineType planarFigureHolePolyline;
 
   if (m_PlanarFigure->GetPolyLinesSize() == 2)
     planarFigureHolePolyline = m_PlanarFigure->GetPolyLine(1);
 
 
   // Determine x- and y-dimensions depending on principal axis
   // TODO use plane geometry normal to determine that automatically, then check whether the PF is aligned with one of the three principal axis
   int i0, i1;
   switch ( axis )
   {
   case 0:
     i0 = 1;
     i1 = 2;
     break;
 
   case 1:
     i0 = 0;
     i1 = 2;
     break;
 
   case 2:
   default:
     i0 = 0;
     i1 = 1;
     break;
   }
 
   // store the polyline contour as vtkPoints object
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   for (const auto& point : planarFigurePolyline)
   {
     Point3D point3D;
 
     // Convert 2D point back to the local index coordinates of the selected image
     planarFigurePlaneGeometry->Map(point, point3D);
     imageGeometry3D->WorldToIndex(point3D, point3D);
 
     points->InsertNextPoint(point3D[i0], point3D[i1], 0);
   }
 
   vtkSmartPointer<vtkPoints> holePoints;
 
   if (!planarFigureHolePolyline.empty())
   {
     holePoints = vtkSmartPointer<vtkPoints>::New();
     Point3D point3D;
 
     for (const auto& point : planarFigureHolePolyline)
     {
       planarFigurePlaneGeometry->Map(point, point3D);
       imageGeometry3D->WorldToIndex(point3D, point3D);
       holePoints->InsertNextPoint(point3D[i0], point3D[i1], 0);
     }
   }
 
   // mark a malformed 2D planar figure ( i.e. area = 0 ) as out of bounds
   // this can happen when all control points of a rectangle lie on the same line = two of the three extents are zero
   double bounds[6] = {0};
   points->GetBounds(bounds);
   bool extent_x = (fabs(bounds[0] - bounds[1])) < mitk::eps;
   bool extent_y = (fabs(bounds[2] - bounds[3])) < mitk::eps;
   bool extent_z = (fabs(bounds[4] - bounds[5])) < mitk::eps;
 
   // throw an exception if a closed planar figure is deformed, i.e. has only one non-zero extent
   if (m_PlanarFigure->IsClosed() && ((extent_x && extent_y) || (extent_x && extent_z)  || (extent_y && extent_z)))
   {
     mitkThrow() << "Figure has a zero area and cannot be used for masking.";
   }
 
   // create a vtkLassoStencilSource and set the points of the Polygon
   vtkSmartPointer<vtkLassoStencilSource> lassoStencil = vtkSmartPointer<vtkLassoStencilSource>::New();
   lassoStencil->SetShapeToPolygon();
   lassoStencil->SetPoints(points);
 
   vtkSmartPointer<vtkLassoStencilSource> holeLassoStencil = nullptr;
 
   if (holePoints.GetPointer() != nullptr)
   {
     holeLassoStencil = vtkSmartPointer<vtkLassoStencilSource>::New();
     holeLassoStencil->SetShapeToPolygon();
     holeLassoStencil->SetPoints(holePoints);
   }
 
   // Export from ITK to VTK (to use a VTK filter)
   typedef itk::VTKImageImport< MaskImage2DType > ImageImportType;
   typedef itk::VTKImageExport< MaskImage2DType > ImageExportType;
 
   typename ImageExportType::Pointer itkExporter = ImageExportType::New();
   itkExporter->SetInput( maskImage );
 //  itkExporter->SetInput( castFilter->GetOutput() );
 
   vtkSmartPointer<vtkImageImport> vtkImporter = vtkSmartPointer<vtkImageImport>::New();
   this->ConnectPipelines( itkExporter, vtkImporter );
 
   // Apply the generated image stencil to the input image
   vtkSmartPointer<vtkImageStencil> imageStencilFilter = vtkSmartPointer<vtkImageStencil>::New();
   imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
   imageStencilFilter->SetStencilConnection(lassoStencil->GetOutputPort());
   imageStencilFilter->ReverseStencilOff();
   imageStencilFilter->SetBackgroundValue( 0 );
   imageStencilFilter->Update();
 
   vtkSmartPointer<vtkImageStencil> holeStencilFilter = nullptr;
 
   if (holeLassoStencil.GetPointer() != nullptr)
   {
     holeStencilFilter = vtkSmartPointer<vtkImageStencil>::New();
     holeStencilFilter->SetInputConnection(imageStencilFilter->GetOutputPort());
     holeStencilFilter->SetStencilConnection(holeLassoStencil->GetOutputPort());
     holeStencilFilter->ReverseStencilOn();
     holeStencilFilter->SetBackgroundValue(0);
     holeStencilFilter->Update();
   }
 
   // Export from VTK back to ITK
   vtkSmartPointer<vtkImageExport> vtkExporter = vtkSmartPointer<vtkImageExport>::New();
   vtkExporter->SetInputConnection( holeStencilFilter.GetPointer() == nullptr
     ? imageStencilFilter->GetOutputPort()
     : holeStencilFilter->GetOutputPort());
   vtkExporter->Update();
 
   typename ImageImportType::Pointer itkImporter = ImageImportType::New();
   this->ConnectPipelines( vtkExporter, itkImporter );
   itkImporter->Update();
 
   typedef itk::ImageDuplicator< ImageImportType::OutputImageType > DuplicatorType;
   DuplicatorType::Pointer duplicator = DuplicatorType::New();
   duplicator->SetInputImage( itkImporter->GetOutput() );
   duplicator->Update();
 
   // Store mask
   m_InternalITKImageMask2D = duplicator->GetOutput();
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void PlanarFigureMaskGenerator::InternalCalculateMaskFromOpenPlanarFigure(
   const itk::Image< TPixel, VImageDimension > *image, unsigned int axis )
 {
   typedef itk::Image< unsigned short, 2 >       MaskImage2DType;
   typedef itk::LineIterator< MaskImage2DType >  LineIteratorType;
   typedef MaskImage2DType::IndexType            IndexType2D;
   typedef std::vector< IndexType2D >            IndexVecType;
 
   typename MaskImage2DType::Pointer maskImage = MaskImage2DType::New();
   maskImage->SetOrigin(image->GetOrigin());
   maskImage->SetSpacing(image->GetSpacing());
   maskImage->SetLargestPossibleRegion(image->GetLargestPossibleRegion());
   maskImage->SetBufferedRegion(image->GetBufferedRegion());
   maskImage->SetDirection(image->GetDirection());
   maskImage->SetNumberOfComponentsPerPixel(image->GetNumberOfComponentsPerPixel());
   maskImage->Allocate();
   maskImage->FillBuffer(0);
 
   // all PolylinePoints of the PlanarFigure are stored in a vtkPoints object.
   const mitk::PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
   const typename PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
   const mitk::BaseGeometry *imageGeometry3D = m_inputImage->GetGeometry( 0 );
 
   // Determine x- and y-dimensions depending on principal axis
   // TODO use plane geometry normal to determine that automatically, then check whether the PF is aligned with one of the three principal axis
   int i0, i1;
   switch ( axis )
   {
   case 0:
     i0 = 1;
     i1 = 2;
     break;
 
   case 1:
     i0 = 0;
     i1 = 2;
     break;
 
   case 2:
   default:
     i0 = 0;
     i1 = 1;
     break;
   }
 
   int numPolyLines = m_PlanarFigure->GetPolyLinesSize();
   for ( int lineId = 0; lineId < numPolyLines; ++lineId )
   {
     // store the polyline contour as vtkPoints object
     IndexVecType pointIndices;
     for(const auto& point : planarFigurePolyline)
     {
       Point3D point3D;
 
       planarFigurePlaneGeometry->Map(point, point3D);
       imageGeometry3D->WorldToIndex(point3D, point3D);
 
       IndexType2D index2D;
       index2D[0] = point3D[i0];
       index2D[1] = point3D[i1];
 
       pointIndices.push_back( index2D );
     }
 
     size_t numLineSegments = pointIndices.size() - 1;
     for (size_t i = 0; i < numLineSegments; ++i)
     {
       LineIteratorType lineIt(maskImage, pointIndices[i], pointIndices[i+1]);
       while (!lineIt.IsAtEnd())
       {
         lineIt.Set(1);
         ++lineIt;
       }
     }
   }
 
   // Store mask
   m_InternalITKImageMask2D = maskImage;
 }
 
 bool PlanarFigureMaskGenerator::CheckPlanarFigureIsNotTilted(const PlaneGeometry* planarGeometry, const BaseGeometry *geometry)
 {
   if (!planarGeometry) return false;
   if (!geometry) return false;
 
   unsigned int axis;
   return GetPrincipalAxis(geometry,planarGeometry->GetNormal(), axis);
 }
 
 bool PlanarFigureMaskGenerator::GetPrincipalAxis(
   const BaseGeometry *geometry, Vector3D vector,
   unsigned int &axis )
 {
   vector.Normalize();
   for ( unsigned int i = 0; i < 3; ++i )
   {
     Vector3D axisVector = geometry->GetAxisVector( i );
     axisVector.Normalize();
 
     //normal mitk::eps is to pedantic for this check. See e.g. T27122
     //therefore choose a larger epsilon. The value was set a) as small as
     //possible but b) still allowing to datasets like in (T27122) to pass
     //when floating rounding errors sum up.
     const double epsilon = 5e-5;
     if ( fabs( fabs( axisVector * vector ) - 1.0) < epsilon)
     {
       axis = i;
       return true;
     }
   }
 
   return false;
 }
 
 void PlanarFigureMaskGenerator::CalculateMask()
 {
     if (m_inputImage.IsNull())
     {
         MITK_ERROR << "Image is not set.";
     }
 
     if (m_PlanarFigure.IsNull())
     {
         MITK_ERROR << "PlanarFigure is not set.";
     }
 
     if (m_TimeStep != 0)
     {
         MITK_WARN << "Multiple TimeSteps are not supported in PlanarFigureMaskGenerator (yet).";
     }
 
     const BaseGeometry *imageGeometry = m_inputImage->GetGeometry();
     if ( imageGeometry == nullptr )
     {
       throw std::runtime_error( "Image geometry invalid!" );
     }
 
     if (m_inputImage->GetTimeSteps() > 0)
     {
         mitk::ImageTimeSelector::Pointer imgTimeSel = mitk::ImageTimeSelector::New();
         imgTimeSel->SetInput(m_inputImage);
         imgTimeSel->SetTimeNr(m_TimeStep);
         imgTimeSel->UpdateLargestPossibleRegion();
         m_InternalTimeSliceImage = imgTimeSel->GetOutput();
     }
     else
     {
         m_InternalTimeSliceImage = m_inputImage;
     }
 
     m_InternalITKImageMask2D = nullptr;
     const PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
     const auto *planarFigureGeometry = dynamic_cast< const PlaneGeometry * >( planarFigurePlaneGeometry );
     //const BaseGeometry *imageGeometry = m_inputImage->GetGeometry();
 
     // Find principal direction of PlanarFigure in input image
     unsigned int axis;
     if ( !this->GetPrincipalAxis( imageGeometry,
       planarFigureGeometry->GetNormal(), axis ) )
     {
       throw std::runtime_error( "Non-aligned planar figures not supported!" );
     }
     m_PlanarFigureAxis = axis;
 
     // Find slice number corresponding to PlanarFigure in input image
     itk::Image< unsigned short, 3 >::IndexType index;
     imageGeometry->WorldToIndex( planarFigureGeometry->GetOrigin(), index );
 
     unsigned int slice = index[axis];
     m_PlanarFigureSlice = slice;
 
     // extract image slice which corresponds to the planarFigure and store it in m_InternalImageSlice
     mitk::Image::ConstPointer inputImageSlice = extract2DImageSlice(axis, slice);
     //mitk::IOUtil::Save(inputImageSlice, "/home/fabian/inputSliceImage.nrrd");
     // Compute mask from PlanarFigure
     // rastering for open planar figure:
     if ( !m_PlanarFigure->IsClosed() )
     {
       AccessFixedDimensionByItk_1(inputImageSlice,
         InternalCalculateMaskFromOpenPlanarFigure,
         2, axis)
     }
     else//for closed planar figure
     {
       AccessFixedDimensionByItk_1(inputImageSlice,
                                   InternalCalculateMaskFromPlanarFigure,
                                   2, axis)
     }
 
     //convert itk mask to mitk::Image::Pointer and return it
     mitk::Image::Pointer planarFigureMaskImage;
     planarFigureMaskImage = mitk::GrabItkImageMemory(m_InternalITKImageMask2D);
     //mitk::IOUtil::Save(planarFigureMaskImage, "/home/fabian/planarFigureMaskImage.nrrd");
 
     //Convert2Dto3DImageFilter::Pointer sliceTo3DImageConverter = Convert2Dto3DImageFilter::New();
     //sliceTo3DImageConverter->SetInput(planarFigureMaskImage);
     //sliceTo3DImageConverter->Update();
     //mitk::IOUtil::Save(sliceTo3DImageConverter->GetOutput(), "/home/fabian/3DsliceImage.nrrd");
 
     m_ReferenceImage = inputImageSlice;
     //mitk::IOUtil::Save(m_ReferenceImage, "/home/fabian/referenceImage.nrrd");
     m_InternalMask = planarFigureMaskImage;
 }
 
 void PlanarFigureMaskGenerator::SetTimeStep(unsigned int timeStep)
 {
     if (timeStep != m_TimeStep)
     {
         m_TimeStep = timeStep;
     }
 }
 
-mitk::Image::Pointer PlanarFigureMaskGenerator::GetMask()
+mitk::Image::ConstPointer PlanarFigureMaskGenerator::GetMask()
 {
     if (IsUpdateRequired())
     {
         this->CalculateMask();
         this->Modified();
     }
 
     m_InternalMaskUpdateTime = this->GetMTime();
     return m_InternalMask;
 }
 
 mitk::Image::ConstPointer PlanarFigureMaskGenerator::extract2DImageSlice(unsigned int axis, unsigned int slice)
 {
     // Extract slice with given position and direction from image
     unsigned int dimension = m_InternalTimeSliceImage->GetDimension();
 
     if (dimension == 3)
     {
       ExtractImageFilter::Pointer imageExtractor = ExtractImageFilter::New();
       imageExtractor->SetInput( m_InternalTimeSliceImage );
       imageExtractor->SetSliceDimension( axis );
       imageExtractor->SetSliceIndex( slice );
       imageExtractor->Update();
       return imageExtractor->GetOutput();
     }
     else if(dimension == 2)
     {
       return m_InternalTimeSliceImage;
     }
     else
     {
       MITK_ERROR << "Unsupported image dimension. Dimension is: " << dimension << ". Only 2D and 3D images are supported.";
       return nullptr;
     }
 }
 
 bool PlanarFigureMaskGenerator::IsUpdateRequired() const
 {
     unsigned long thisClassTimeStamp = this->GetMTime();
     unsigned long internalMaskTimeStamp = m_InternalMask->GetMTime();
     unsigned long planarFigureTimeStamp = m_PlanarFigure->GetMTime();
     unsigned long inputImageTimeStamp = m_inputImage->GetMTime();
 
     if (thisClassTimeStamp > m_InternalMaskUpdateTime) // inputs have changed
     {
         return true;
     }
 
     if (m_InternalMaskUpdateTime < planarFigureTimeStamp || m_InternalMaskUpdateTime < inputImageTimeStamp) // mask image has changed outside of this class
     {
         return true;
     }
 
     if (internalMaskTimeStamp > m_InternalMaskUpdateTime) // internal mask has been changed outside of this class
     {
         return true;
     }
 
     return false;
 }
 
 }
 
diff --git a/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.h b/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.h
index 0e61304fef..5c2559fc9d 100644
--- a/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.h
+++ b/Modules/ImageStatistics/mitkPlanarFigureMaskGenerator.h
@@ -1,145 +1,146 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKPLANARFIGUREMASKGENERATOR
 #define MITKPLANARFIGUREMASKGENERATOR
 
 #include <MitkImageStatisticsExports.h>
 #include <itkImage.h>
 #include <mitkImage.h>
 #include <mitkMaskGenerator.h>
 #include <mitkPlanarFigure.h>
 #include <vtkSmartPointer.h>
 
 namespace mitk
 {
   /**
    * \class PlanarFigureMaskGenerator
    * \brief Derived from MaskGenerator. This class is used to convert a mitk::PlanarFigure into a binary image mask
    */
   class MITKIMAGESTATISTICS_EXPORT PlanarFigureMaskGenerator : public MaskGenerator
   {
   public:
     /** Standard Self typedef */
     typedef PlanarFigureMaskGenerator Self;
     typedef MaskGenerator Superclass;
     typedef itk::SmartPointer<Self> Pointer;
     typedef itk::SmartPointer<const Self> ConstPointer;
 
     /** Method for creation through the object factory. */
     itkNewMacro(Self); /** Runtime information support. */
       itkTypeMacro(PlanarFigureMaskGenerator, MaskGenerator);
 
       /**
        * @brief GetMask Computes and returns the mask
        * @return mitk::Image::Pointer of the generated mask
        */
-      mitk::Image::Pointer GetMask() override;
+    mitk::Image::ConstPointer GetMask() override;
 
-    void SetPlanarFigure(mitk::PlanarFigure::Pointer planarFigure);
+    void SetPlanarFigure(mitk::PlanarFigure* planarFigure);
 
     mitk::Image::ConstPointer GetReferenceImage() override;
 
     /**
      * @brief SetTimeStep is used to set the time step for which the mask is to be generated
      * @param timeStep
      */
     void SetTimeStep(unsigned int timeStep) override;
 
     itkGetConstMacro(PlanarFigureAxis, unsigned int);
     itkGetConstMacro(PlanarFigureSlice, unsigned int);
 
     /** Helper function that indicates if a passed planar geometry is tilted regarding a given geometry and its main axis.
      *@pre If either planarGeometry or geometry is nullptr it will return false.*/
     static bool CheckPlanarFigureIsNotTilted(const PlaneGeometry* planarGeometry, const BaseGeometry *geometry);
 
   protected:
     PlanarFigureMaskGenerator()
       : Superclass(),
         m_ReferenceImage(nullptr),
         m_PlanarFigureAxis(0),
         m_InternalMaskUpdateTime(0),
         m_PlanarFigureSlice(0)
     {
       m_InternalMask = mitk::Image::New();
     }
 
   private:
     void CalculateMask();
 
     template <typename TPixel, unsigned int VImageDimension>
     void InternalCalculateMaskFromPlanarFigure(const itk::Image<TPixel, VImageDimension> *image, unsigned int axis);
 
     template <typename TPixel, unsigned int VImageDimension>
     void InternalCalculateMaskFromOpenPlanarFigure(const itk::Image<TPixel, VImageDimension> *image, unsigned int axis);
 
     mitk::Image::ConstPointer extract2DImageSlice(unsigned int axis, unsigned int slice);
 
     /** Helper function that deduces if the passed vector is equal to one of the primary axis of the geometry.*/
     static bool GetPrincipalAxis(const BaseGeometry *geometry, Vector3D vector, unsigned int &axis);
 
     /** Connection from ITK to VTK */
     template <typename ITK_Exporter, typename VTK_Importer>
     void ConnectPipelines(ITK_Exporter exporter, vtkSmartPointer<VTK_Importer> importer)
     {
       importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
       importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
       importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
       importer->SetSpacingCallback(exporter->GetSpacingCallback());
       importer->SetOriginCallback(exporter->GetOriginCallback());
       importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
       importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
       importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
       importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
       importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
       importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
       importer->SetCallbackUserData(exporter->GetCallbackUserData());
     }
 
     /** Connection from VTK to ITK */
     template <typename VTK_Exporter, typename ITK_Importer>
     void ConnectPipelines(vtkSmartPointer<VTK_Exporter> exporter, ITK_Importer importer)
     {
       importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
       importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
       importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
       importer->SetSpacingCallback(exporter->GetSpacingCallback());
       importer->SetOriginCallback(exporter->GetOriginCallback());
       importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
       importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
       importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
       importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
       importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
       importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
       importer->SetCallbackUserData(exporter->GetCallbackUserData());
     }
 
     bool IsUpdateRequired() const;
 
     mitk::PlanarFigure::Pointer m_PlanarFigure;
     itk::Image<unsigned short, 2>::Pointer m_InternalITKImageMask2D;
     mitk::Image::ConstPointer m_InternalTimeSliceImage;
     mitk::Image::ConstPointer m_ReferenceImage;
     unsigned int m_PlanarFigureAxis;
     unsigned long m_InternalMaskUpdateTime;
     unsigned int m_PlanarFigureSlice;
+    mitk::Image::Pointer m_InternalMask;
   };
 
 } // namespace mitk
 
 #endif // MITKPLANARFIGUREMASKGENERATOR
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
index c07bcda386..f3cf23d68b 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
@@ -1,221 +1,222 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkImageStatisticsCalculationJob.h"
 
 #include "mitkImageStatisticsCalculator.h"
 #include <mitkImageMaskGenerator.h>
 #include <mitkPlanarFigureMaskGenerator.h>
 #include <mitkIgnorePixelMaskGenerator.h>
 
 QmitkImageStatisticsCalculationJob::QmitkImageStatisticsCalculationJob()
   : QThread()
   , m_StatisticsImage(nullptr)
   , m_BinaryMask(nullptr)
   , m_PlanarFigureMask(nullptr)
   , m_IgnoreZeros(false)
   , m_HistogramNBins(100)
   , m_CalculationSuccessful(false)
 {
 }
 
 QmitkImageStatisticsCalculationJob::~QmitkImageStatisticsCalculationJob()
 {
 }
 
 void QmitkImageStatisticsCalculationJob::Initialize(const mitk::Image *image,
                                                     const mitk::Image *binaryImage,
                                                     const mitk::PlanarFigure *planarFig)
 {
   this->m_StatisticsImage = image;
   this->m_BinaryMask = binaryImage;
   this->m_PlanarFigureMask = planarFig;
 }
 
 mitk::ImageStatisticsContainer* QmitkImageStatisticsCalculationJob::GetStatisticsData() const
 {
   return this->m_StatisticsContainer.GetPointer();
 }
 
 const mitk::Image* QmitkImageStatisticsCalculationJob::GetStatisticsImage() const
 {
   return this->m_StatisticsImage.GetPointer();
 }
 
 const mitk::Image* QmitkImageStatisticsCalculationJob::GetMaskImage() const
 {
   return this->m_BinaryMask.GetPointer();
 }
 
 const mitk::PlanarFigure* QmitkImageStatisticsCalculationJob::GetPlanarFigure() const
 {
   return this->m_PlanarFigureMask.GetPointer();
 }
 
 void QmitkImageStatisticsCalculationJob::SetIgnoreZeroValueVoxel(bool _arg)
 {
   this->m_IgnoreZeros = _arg;
 }
 
 bool QmitkImageStatisticsCalculationJob::GetIgnoreZeroValueVoxel() const
 {
   return this->m_IgnoreZeros;
 }
 
 void QmitkImageStatisticsCalculationJob::SetHistogramNBins(unsigned int nbins)
 {
   this->m_HistogramNBins = nbins;
 }
 
 unsigned int QmitkImageStatisticsCalculationJob::GetHistogramNBins() const
 {
   return this->m_HistogramNBins;
 }
 
 std::string QmitkImageStatisticsCalculationJob::GetLastErrorMessage() const
 {
   return m_message;
 }
 
 const QmitkImageStatisticsCalculationJob::HistogramType*
 QmitkImageStatisticsCalculationJob::GetTimeStepHistogram(unsigned int t) const
 {
   if (t >= this->m_HistogramVector.size())
     return nullptr;
 
   return this->m_HistogramVector.at(t).GetPointer();
 }
 
 bool QmitkImageStatisticsCalculationJob::GetStatisticsUpdateSuccessFlag() const
 {
   return m_CalculationSuccessful;
 }
 
 void QmitkImageStatisticsCalculationJob::run()
 {
   bool statisticCalculationSuccessful = true;
   mitk::ImageStatisticsCalculator::Pointer calculator = mitk::ImageStatisticsCalculator::New();
 
   if(this->m_StatisticsImage.IsNotNull())
   {
     calculator->SetInputImage(m_StatisticsImage);
   }
   else
   {
     statisticCalculationSuccessful = false;
   }
 
   // Bug 13416 : The ImageStatistics::SetImageMask() method can throw exceptions, i.e. when the dimensionality
   // of the masked and input image differ, we need to catch them and mark the calculation as failed
   // the same holds for the ::SetPlanarFigure()
   try
   {
     if(this->m_BinaryMask.IsNotNull())
     {
       mitk::ImageMaskGenerator::Pointer imgMask = mitk::ImageMaskGenerator::New();
-      imgMask->SetImageMask(m_BinaryMask->Clone());
+      imgMask->SetInputImage(m_StatisticsImage);
+      imgMask->SetImageMask(m_BinaryMask);
       calculator->SetMask(imgMask.GetPointer());
     }
     if(this->m_PlanarFigureMask.IsNotNull())
     {
       mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
       pfMaskGen->SetInputImage(m_StatisticsImage);
       pfMaskGen->SetPlanarFigure(m_PlanarFigureMask->Clone());
       calculator->SetMask(pfMaskGen.GetPointer());
     }
   }
   catch (const mitk::Exception& e)
   {
     MITK_ERROR << "MITK Exception: " << e.what();
     m_message = e.what();
     statisticCalculationSuccessful = false;
   }
   catch( const itk::ExceptionObject& e)
   {
     MITK_ERROR << "ITK Exception:" << e.what();
     m_message = e.what();
     statisticCalculationSuccessful = false;
   }
   catch ( const std::runtime_error &e )
   {
     MITK_ERROR<< "Runtime Exception: " << e.what();
     m_message = e.what();
     statisticCalculationSuccessful = false;
   }
   catch ( const std::exception &e )
   {
     MITK_ERROR<< "Standard Exception: " << e.what();
     m_message = e.what();
     statisticCalculationSuccessful = false;
   }
 
   if (this->m_IgnoreZeros)
   {
       mitk::IgnorePixelMaskGenerator::Pointer ignorePixelValueMaskGen = mitk::IgnorePixelMaskGenerator::New();
       ignorePixelValueMaskGen->SetIgnoredPixelValue(0);
       ignorePixelValueMaskGen->SetInputImage(m_StatisticsImage);
       calculator->SetSecondaryMask(ignorePixelValueMaskGen.GetPointer());
   }
   else
   {
       calculator->SetSecondaryMask(nullptr);
   }
 
   calculator->SetNBinsForHistogramStatistics(m_HistogramNBins);
 
     try
     {
       calculator->GetStatistics();
     }
     catch ( mitk::Exception& e)
     {
       m_message = e.GetDescription();
       MITK_ERROR<< "MITK Exception: " << e.what();
       statisticCalculationSuccessful = false;
     }
     catch ( const std::runtime_error &e )
     {
       m_message = "Failure: " + std::string(e.what());
       MITK_ERROR<< "Runtime Exception: " << e.what();
       statisticCalculationSuccessful = false;
     }
     catch ( const std::exception &e )
     {
       m_message = "Failure: " + std::string(e.what());
       MITK_ERROR<< "Standard Exception: " << e.what();
       statisticCalculationSuccessful = false;
     }
 
   this->m_CalculationSuccessful = statisticCalculationSuccessful;
 
   if(statisticCalculationSuccessful)
   {
     m_StatisticsContainer = calculator->GetStatistics();
     this->m_HistogramVector.clear();
 
     for (unsigned int i = 0; i < m_StatisticsImage->GetTimeSteps(); i++)
     {
       HistogramType::ConstPointer tempHistogram;
       try {
         if(calculator->GetStatistics()->TimeStepExists(i))
         {
           tempHistogram = calculator->GetStatistics()->GetStatisticsForTimeStep(i).m_Histogram;
           this->m_HistogramVector.push_back(tempHistogram);
         }
       } catch (mitk::Exception&) {
         MITK_WARN << ":-(";
       }
 
     }
 
   }
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationRunnable.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationRunnable.cpp
index 51850b06ed..7dc62e5227 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationRunnable.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationRunnable.cpp
@@ -1,186 +1,187 @@
 /*===================================================================
 
 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 "QmitkImageStatisticsCalculationRunnable.h"
 
 #include "mitkImageStatisticsCalculator.h"
 #include <mitkImageMaskGenerator.h>
 #include <mitkPlanarFigureMaskGenerator.h>
 #include <mitkIgnorePixelMaskGenerator.h>
 #include "mitkStatisticsToImageRelationRule.h"
 #include "mitkStatisticsToMaskRelationRule.h"
 #include "mitkImageStatisticsContainerManager.h"
 #include "mitkProperties.h"
 
 QmitkImageStatisticsCalculationRunnable::QmitkImageStatisticsCalculationRunnable()
   : QmitkDataGenerationJobBase()
   , m_StatisticsImage(nullptr)
   , m_BinaryMask(nullptr)
   , m_PlanarFigureMask(nullptr)
   , m_IgnoreZeros(false)
   , m_HistogramNBins(100)
 {
 }
 
 QmitkImageStatisticsCalculationRunnable::~QmitkImageStatisticsCalculationRunnable()
 {
 }
 
 void QmitkImageStatisticsCalculationRunnable::Initialize(const mitk::Image *image,
   const mitk::Image *binaryImage,
   const mitk::PlanarFigure *planarFig)
 {
   this->m_StatisticsImage = image;
   this->m_BinaryMask = binaryImage;
   this->m_PlanarFigureMask = planarFig;
 }
 
 mitk::ImageStatisticsContainer* QmitkImageStatisticsCalculationRunnable::GetStatisticsData() const
 {
   return this->m_StatisticsContainer.GetPointer();
 }
 
 const mitk::Image* QmitkImageStatisticsCalculationRunnable::GetStatisticsImage() const
 {
   return this->m_StatisticsImage.GetPointer();
 }
 
 const mitk::Image* QmitkImageStatisticsCalculationRunnable::GetMaskImage() const
 {
   return this->m_BinaryMask.GetPointer();
 }
 
 const mitk::PlanarFigure* QmitkImageStatisticsCalculationRunnable::GetPlanarFigure() const
 {
   return this->m_PlanarFigureMask.GetPointer();
 }
 
 void QmitkImageStatisticsCalculationRunnable::SetIgnoreZeroValueVoxel(bool _arg)
 {
   this->m_IgnoreZeros = _arg;
 }
 
 bool QmitkImageStatisticsCalculationRunnable::GetIgnoreZeroValueVoxel() const
 {
   return this->m_IgnoreZeros;
 }
 
 void QmitkImageStatisticsCalculationRunnable::SetHistogramNBins(unsigned int nbins)
 {
   this->m_HistogramNBins = nbins;
 }
 
 unsigned int QmitkImageStatisticsCalculationRunnable::GetHistogramNBins() const
 {
   return this->m_HistogramNBins;
 }
 
 QmitkDataGenerationJobBase::ResultMapType QmitkImageStatisticsCalculationRunnable::GetResults() const
 {
   ResultMapType result;
   result.emplace("statistics", this->GetStatisticsData());
   return result;
 }
 
 bool QmitkImageStatisticsCalculationRunnable::RunComputation()
 {
   bool statisticCalculationSuccessful = true;
   mitk::ImageStatisticsCalculator::Pointer calculator = mitk::ImageStatisticsCalculator::New();
 
   if (this->m_StatisticsImage.IsNotNull())
   {
     calculator->SetInputImage(m_StatisticsImage);
   }
   else
   {
     statisticCalculationSuccessful = false;
   }
 
   // Bug 13416 : The ImageStatistics::SetImageMask() method can throw exceptions, i.e. when the dimensionality
   // of the masked and input image differ, we need to catch them and mark the calculation as failed
   // the same holds for the ::SetPlanarFigure()
   try
   {
     if (this->m_BinaryMask.IsNotNull())
     {
       mitk::ImageMaskGenerator::Pointer imgMask = mitk::ImageMaskGenerator::New();
-      imgMask->SetImageMask(m_BinaryMask->Clone());
+      imgMask->SetInputImage(m_StatisticsImage);
+      imgMask->SetImageMask(m_BinaryMask);
       calculator->SetMask(imgMask.GetPointer());
     }
     if (this->m_PlanarFigureMask.IsNotNull())
     {
       mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
       pfMaskGen->SetInputImage(m_StatisticsImage);
       pfMaskGen->SetPlanarFigure(m_PlanarFigureMask->Clone());
       calculator->SetMask(pfMaskGen.GetPointer());
     }
   }
   catch (const std::exception &e)
   {
     MITK_ERROR << "Error while configuring the statistics calculator: " << e.what();
     m_LastErrorMessage = e.what();
     statisticCalculationSuccessful = false;
   }
 
   if (this->m_IgnoreZeros)
   {
     mitk::IgnorePixelMaskGenerator::Pointer ignorePixelValueMaskGen = mitk::IgnorePixelMaskGenerator::New();
     ignorePixelValueMaskGen->SetIgnoredPixelValue(0);
     ignorePixelValueMaskGen->SetInputImage(m_StatisticsImage);
     calculator->SetSecondaryMask(ignorePixelValueMaskGen.GetPointer());
   }
   else
   {
     calculator->SetSecondaryMask(nullptr);
   }
 
   calculator->SetNBinsForHistogramStatistics(m_HistogramNBins);
 
   try
   {
     calculator->GetStatistics();
   }
   catch (const std::exception &e)
   {
     m_LastErrorMessage = "Failure while calculating the statistics: " + std::string(e.what());
     MITK_ERROR << m_LastErrorMessage;
     statisticCalculationSuccessful = false;
   }
 
   if (statisticCalculationSuccessful)
   {
     m_StatisticsContainer = calculator->GetStatistics();
 
     auto imageRule = mitk::StatisticsToImageRelationRule::New();
     imageRule->Connect(m_StatisticsContainer, m_StatisticsImage);
 
     if (nullptr != m_PlanarFigureMask)
     {
       auto maskRule = mitk::StatisticsToMaskRelationRule::New();
       maskRule->Connect(m_StatisticsContainer, m_PlanarFigureMask);
     }
 
     if (nullptr != m_BinaryMask)
     {
       auto maskRule = mitk::StatisticsToMaskRelationRule::New();
       maskRule->Connect(m_StatisticsContainer, m_BinaryMask);
     }
 
     m_StatisticsContainer->SetProperty(mitk::STATS_HISTOGRAM_BIN_PROPERTY_NAME.c_str(), mitk::UIntProperty::New(m_HistogramNBins));
     m_StatisticsContainer->SetProperty(mitk::STATS_IGNORE_ZERO_VOXEL_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(m_IgnoreZeros));
   }
   return statisticCalculationSuccessful;
 }
diff --git a/Modules/MatchPointRegistration/include/mitkRegEvaluationMapper2D.h b/Modules/MatchPointRegistration/include/mitkRegEvaluationMapper2D.h
index 54e35034e9..8c8481819d 100644
--- a/Modules/MatchPointRegistration/include/mitkRegEvaluationMapper2D.h
+++ b/Modules/MatchPointRegistration/include/mitkRegEvaluationMapper2D.h
@@ -1,248 +1,248 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITK_REG_EVALUATION_MAPPER_2D_H
 #define MITK_REG_EVALUATION_MAPPER_2D_H
 
 //MatchPoint
 #include <mapRegistration.h>
 #include "mitkRegEvaluationObject.h"
 
 //MITK
 #include <mitkCommon.h>
 
 //MITK Rendering
 #include "mitkBaseRenderer.h"
 #include "mitkVtkMapper.h"
 #include "mitkExtractSliceFilter.h"
 
 //VTK
 #include <vtkSmartPointer.h>
 #include <vtkPropAssembly.h>
 
 //MITK
 #include "MitkMatchPointRegistrationExports.h"
 
 class vtkActor;
 class vtkPolyDataMapper;
 class vtkPlaneSource;
 class vtkImageData;
 class vtkLookupTable;
 class vtkImageExtractComponents;
 class vtkImageReslice;
 class vtkImageChangeInformation;
 class vtkPoints;
 class vtkMitkThickSlicesFilter;
 class vtkPolyData;
 class vtkMitkApplyLevelWindowToRGBFilter;
 class vtkMitkLevelWindowFilter;
 
 namespace mitk {
 
 /** \brief Mapper to resample and display 2D slices of registration evaluation visualization.
  * \ingroup Mapper
  */
 class MITKMATCHPOINTREGISTRATION_EXPORT RegEvaluationMapper2D : public VtkMapper
 {
 
 public:
   /** Standard class typedefs. */
   mitkClassMacro( RegEvaluationMapper2D,VtkMapper );
 
   /** Method for creation through the object factory. */
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
   const mitk::DataNode* GetTargetNode(void);
   const mitk::DataNode* GetMovingNode(void);
   /** \brief Get the target image to map */
   const mitk::Image *GetTargetImage(void);
   /** \brief Get the moving image to map */
   const mitk::Image *GetMovingImage(void);
   /** \brief Get the target image to map */
   const mitk::MAPRegistrationWrapper *GetRegistration(void);
 
   /** \brief Checks whether this mapper needs to update itself and generate
    * data. */
   void Update(mitk::BaseRenderer * renderer) override;
 
   //### methods of MITK-VTK rendering pipeline
   vtkProp* GetVtkProp(mitk::BaseRenderer* renderer) override;
   //### end of methods of MITK-VTK rendering pipeline
 
   /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
   /**
-     * To render transveral, coronal, and sagittal, the mapper is called three times.
+     * To render axial, coronal, and sagittal, the mapper is called three times.
      * For performance reasons, the corresponding data for each view is saved in the
      * internal helper class LocalStorage. This allows rendering n views with just
      * 1 mitkMapper using n vtkMapper.
      * */
   class MITKMATCHPOINTREGISTRATION_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
   {
   public:
     /** \brief Actor of a 2D render window. */
     vtkSmartPointer<vtkActor> m_Actor;
 
     vtkSmartPointer<vtkPropAssembly> m_Actors;
     /** \brief Mapper of a 2D render window. */
     vtkSmartPointer<vtkPolyDataMapper> m_Mapper;
     /** \brief Current slice of a 2D render window.*/
     vtkSmartPointer<vtkImageData> m_EvaluationImage;
 
     /** \brief Empty vtkPolyData that is set when rendering geometry does not
       *   intersect the image geometry.
       *   \warning This member variable is set to nullptr,
       *   if no image geometry is inside the plane geometry
       *   of the respective render window. Any user of this
       *   slice has to check whether it is set to nullptr!
       */
     vtkSmartPointer<vtkPolyData> m_EmptyPolyData;
     /** \brief Plane on which the slice is rendered as texture. */
     vtkSmartPointer<vtkPlaneSource> m_Plane;
     /** \brief The texture which is used to render the current slice. */
     vtkSmartPointer<vtkTexture> m_Texture;
     /** \brief The lookuptables for colors and level window */
     vtkSmartPointer<vtkLookupTable> m_ColorLookupTable;
     vtkSmartPointer<vtkLookupTable> m_DefaultLookupTable;
     /** \brief The actual reslicer (one per renderer) */
     mitk::ExtractSliceFilter::Pointer m_Reslicer;
 
     /** part of the target image that is relevant for the rendering*/
     mitk::Image::Pointer m_slicedTargetImage;
     /** part of the moving image mapped into the slicedTargetImage
      geometry*/
     mitk::Image::Pointer m_slicedMappedImage;
 
     /** \brief Timestamp of last update of stored data. */
     itk::TimeStamp m_LastUpdateTime;
 
     /** \brief mmPerPixel relation between pixel and mm. (World spacing).*/
     mitk::ScalarType* m_mmPerPixel;
 
     /** \brief This filter is used to apply the level window to target image. */
     vtkSmartPointer<vtkMitkLevelWindowFilter> m_TargetLevelWindowFilter;
 
     /** \brief This filter is used to apply the level window to moving image. */
     vtkSmartPointer<vtkMitkLevelWindowFilter> m_MappedLevelWindowFilter;
 
     vtkSmartPointer<vtkImageExtractComponents> m_TargetExtractFilter;
     vtkSmartPointer<vtkImageExtractComponents> m_MappedExtractFilter;
 
     /** \brief Default constructor of the local storage. */
     LocalStorage();
     /** \brief Default deconstructor of the local storage. */
     ~LocalStorage() override;
   };
 
   /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
   mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
   /** \brief Get the LocalStorage corresponding to the current renderer. */
   LocalStorage* GetLocalStorage(mitk::BaseRenderer* renderer);
 
   /** \brief Set the default properties for general image rendering. */
   static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = nullptr, bool overwrite = false);
 
 protected:
   /** \brief Transforms the actor to the actual position in 3D.
     *   \param renderer The current renderer corresponding to the render window.
     */
   void TransformActor(mitk::BaseRenderer* renderer);
 
   /** \brief Generates a plane according to the size of the resliced image in milimeters.
     *
     * In VTK a vtkPlaneSource is defined through three points. The origin and two
     * points defining the axes of the plane (see VTK documentation). The origin is
     * set to (xMin; yMin; Z), where xMin and yMin are the minimal bounds of the
     * resliced image in space. Z is relevant for blending and the layer property.
     * The center of the plane (C) is also the center of the view plane (cf. the image above).
     *
     * \note For the standard MITK view with three 2D render windows showing three
     * different slices, three such planes are generated. All these planes are generated
     * in the XY-plane (even if they depict a YZ-slice of the volume).
     *
     */
   void GeneratePlane(mitk::BaseRenderer* renderer, double planeBounds[6]);
 
   /** Default constructor */
   RegEvaluationMapper2D();
   /** Default deconstructor */
   ~RegEvaluationMapper2D() override;
 
   /** \brief Does the actual resampling, without rendering the image yet.
     * All the data is generated inside this method. The vtkProp (or Actor)
     * is filled with content (i.e. the resliced image).
     *
     * After generation, a 4x4 transformation matrix(t) of the current slice is obtained
     * from the vtkResliceImage object via GetReslicesAxis(). This matrix is
     * applied to each textured plane (actor->SetUserTransform(t)) to transform everything
     * to the actual 3D position (cf. the following image).
     *
     * \image html cameraPositioning3D.png
     *
     */
   void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
 
   void PrepareContour( mitk::DataNode* datanode, LocalStorage * localStorage );
 
   void PrepareDifference( LocalStorage * localStorage );
 
   void PrepareWipe(mitk::DataNode* datanode, LocalStorage * localStorage, const Point2D& currentIndex2D);
 
   void PrepareCheckerBoard( mitk::DataNode* datanode, LocalStorage * localStorage );
 
   void PrepareColorBlend( LocalStorage * localStorage );
 
   void PrepareBlend( mitk::DataNode* datanode, LocalStorage * localStorage );
 
   /** \brief This method uses the vtkCamera clipping range and the layer property
     * to calcualte the depth of the object (e.g. image or contour). The depth is used
     * to keep the correct order for the final VTK rendering.*/
   float CalculateLayerDepth(mitk::BaseRenderer* renderer);
 
   /** \brief This method applies (or modifies) the lookuptable for all types of images.
    * \warning To use the lookup table, the property 'Lookup Table' must be set and a 'Image Rendering.Mode'
    * which uses the lookup table must be set.
 */
   void ApplyLookuptable(mitk::BaseRenderer* renderer, const mitk::DataNode* dataNode, vtkMitkLevelWindowFilter* levelFilter);
 
   /**
    * @brief ApplyLevelWindow Apply the level window for the given renderer.
    * \warning To use the level window, the property 'LevelWindow' must be set and a 'Image Rendering.Mode' which uses the level window must be set.
    * @param renderer Level window for which renderer?
    * @param dataNode
    * @param levelFilter
    */
   void ApplyLevelWindow(mitk::BaseRenderer *renderer, const mitk::DataNode* dataNode, vtkMitkLevelWindowFilter* levelFilter);
 
   /** \brief Set the opacity of the actor. */
   void ApplyOpacity( mitk::BaseRenderer* renderer );
 
   /**
     * \brief Calculates whether the given rendering geometry intersects the
     * given SlicedGeometry3D.
     *
     * This method checks if the given PlaneGeometry intersects the given
     * SlicedGeometry3D. It calculates the distance of the PlaneGeometry to all
     * 8 cornerpoints of the SlicedGeometry3D. If all distances have the same
     * sign (all positive or all negative) there is no intersection.
     * If the distances have different sign, there is an intersection.
     * 
     * \param renderingGeometry
     * \param imageGeometry
     **/
   bool RenderingGeometryIntersectsImage( const PlaneGeometry* renderingGeometry, SlicedGeometry3D* imageGeometry );
 };
 
 } // namespace mitk
 
 #endif /* MITKRegEvaluationMapper2D_H_HEADER_INCLUDED_C10E906E */
diff --git a/Modules/MatchPointRegistration/src/Helper/mitkImageMappingHelper.cpp b/Modules/MatchPointRegistration/src/Helper/mitkImageMappingHelper.cpp
index fdf8b80dda..1721cdf683 100644
--- a/Modules/MatchPointRegistration/src/Helper/mitkImageMappingHelper.cpp
+++ b/Modules/MatchPointRegistration/src/Helper/mitkImageMappingHelper.cpp
@@ -1,444 +1,444 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <itkInterpolateImageFunction.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkLinearInterpolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkGeometry3D.h>
 #include <mitkImageToItk.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkLabelSetImage.h>
 
 #include "mapRegistration.h"
 
 #include "mitkImageMappingHelper.h"
 #include "mitkRegistrationHelper.h"
 
 template <typename TImage >
 typename ::itk::InterpolateImageFunction< TImage >::Pointer generateInterpolator(mitk::ImageMappingInterpolator::Type interpolatorType)
 {
   typedef ::itk::InterpolateImageFunction< TImage > BaseInterpolatorType;
   typename BaseInterpolatorType::Pointer result;
 
   switch (interpolatorType)
   {
   case mitk::ImageMappingInterpolator::NearestNeighbor:
     {
       result = ::itk::NearestNeighborInterpolateImageFunction<TImage>::New();
       break;
     }
   case mitk::ImageMappingInterpolator::BSpline_3:
     {
       typename ::itk::BSplineInterpolateImageFunction<TImage>::Pointer spInterpolator = ::itk::BSplineInterpolateImageFunction<TImage>::New();
       spInterpolator->SetSplineOrder(3);
       result = spInterpolator;
       break;
     }
   case mitk::ImageMappingInterpolator::WSinc_Hamming:
     {
       result = ::itk::WindowedSincInterpolateImageFunction<TImage,4>::New();
       break;
     }
   case mitk::ImageMappingInterpolator::WSinc_Welch:
     {
       result = ::itk::WindowedSincInterpolateImageFunction<TImage,4,::itk::Function::WelchWindowFunction<4> >::New();
       break;
     }
   default:
     {
       result = ::itk::LinearInterpolateImageFunction<TImage>::New();
       break;
     }
 
   }
 
   return result;
 };
 
 template <typename TPixelType, unsigned int VImageDimension >
 void doMITKMap(const ::itk::Image<TPixelType,VImageDimension>* input, mitk::ImageMappingHelper::ResultImageType::Pointer& result, const mitk::ImageMappingHelper::RegistrationType*& registration,
   bool throwOnOutOfInputAreaError, const double& paddingValue, const mitk::ImageMappingHelper::ResultImageGeometryType*& resultGeometry,
   bool throwOnMappingError, const double& errorValue, mitk::ImageMappingInterpolator::Type interpolatorType)
 {
   typedef ::map::core::Registration<VImageDimension,VImageDimension> ConcreteRegistrationType;
   typedef ::map::core::ImageMappingTask<ConcreteRegistrationType, ::itk::Image<TPixelType,VImageDimension>, ::itk::Image<TPixelType,VImageDimension> > MappingTaskType;
   typename MappingTaskType::Pointer spTask = MappingTaskType::New();
 
   typedef typename MappingTaskType::ResultImageDescriptorType ResultImageDescriptorType;
   typename ResultImageDescriptorType::Pointer resultDescriptor;
 
   //check if image and result geometry fits the passed registration
   /////////////////////////////////////////////////////////////////
   if (registration->getMovingDimensions()!=VImageDimension)
   {
     map::core::OStringStream str;
     str << "Dimension of MITK image ("<<VImageDimension<<") does not equal the moving dimension of the registration object ("<<registration->getMovingDimensions()<<").";
     throw mitk::AccessByItkException(str.str());
   }
 
   if (registration->getTargetDimensions()!=VImageDimension)
   {
     map::core::OStringStream str;
     str << "Dimension of MITK image ("<<VImageDimension<<") does not equal the target dimension of the registration object ("<<registration->getTargetDimensions()<<").";
     throw mitk::AccessByItkException(str.str());
   }
 
   const ConcreteRegistrationType* castedReg = dynamic_cast<const ConcreteRegistrationType*>(registration);
 
   if (registration->getTargetDimensions()==2 && resultGeometry)
   {
     mitk::ImageMappingHelper::ResultImageGeometryType::BoundsArrayType bounds = resultGeometry->GetBounds();
 
     if (bounds[4]!=0 || bounds[5]!=0)
     {
       //array "bounds" is constructed as [min Dim1, max Dim1, min Dim2, max Dim2, min Dim3, max Dim3]
       //therfore [4] and [5] must be 0
 
       map::core::OStringStream str;
       str << "Dimension of defined result geometry does not equal the target dimension of the registration object ("<<registration->getTargetDimensions()<<").";
       throw mitk::AccessByItkException(str.str());
     }
   }
 
   //check/create resultDescriptor
   /////////////////////////
   if (resultGeometry)
   {
     resultDescriptor = ResultImageDescriptorType::New();
 
     typename ResultImageDescriptorType::PointType origin;
     typename ResultImageDescriptorType::SizeType size;
     typename ResultImageDescriptorType::SpacingType fieldSpacing;
     typename ResultImageDescriptorType::DirectionType matrix;
 
     mitk::ImageMappingHelper::ResultImageGeometryType::BoundsArrayType geoBounds = resultGeometry->GetBounds();
     mitk::Vector3D geoSpacing = resultGeometry->GetSpacing();
     mitk::Point3D geoOrigin = resultGeometry->GetOrigin();
     mitk::AffineTransform3D::MatrixType geoMatrix = resultGeometry->GetIndexToWorldTransform()->GetMatrix();
 
     for (unsigned int i = 0; i<VImageDimension; ++i)
     {
       origin[i] = static_cast<typename ResultImageDescriptorType::PointType::ValueType>(geoOrigin[i]);
       fieldSpacing[i] = static_cast<typename ResultImageDescriptorType::SpacingType::ValueType>(geoSpacing[i]);
       size[i] = static_cast<typename ResultImageDescriptorType::SizeType::SizeValueType>(geoBounds[(2*i)+1]-geoBounds[2*i])*fieldSpacing[i];
     }
 
     //Matrix extraction
     matrix.SetIdentity();
     unsigned int i;
     unsigned int j;
 
     /// \warning 2D MITK images could have a 3D rotation, since they have a 3x3 geometry matrix.
     /// If it is only a rotation around the transversal plane normal, it can be express with a 2x2 matrix.
     /// In this case, the ITK image conservs this information and is identical to the MITK image!
     /// If the MITK image contains any other rotation, the ITK image will have no rotation at all.
     /// Spacing is of course conserved in both cases.
 
     // the following loop devides by spacing now to normalize columns.
     // counterpart of InitializeByItk in mitkImage.h line 372 of revision 15092.
 
     // Check if information is lost
     if (  VImageDimension == 2)
     {
       if (  ( geoMatrix[0][2] != 0) ||
         ( geoMatrix[1][2] != 0) ||
         ( geoMatrix[2][0] != 0) ||
         ( geoMatrix[2][1] != 0) ||
         (( geoMatrix[2][2] != 1) &&  ( geoMatrix[2][2] != -1) ))
       {
         // The 2D MITK image contains 3D rotation information.
         // This cannot be expressed in a 2D ITK image, so the ITK image will have no rotation
       }
       else
       {
         // The 2D MITK image can be converted to an 2D ITK image without information loss!
         for ( i=0; i < 2; ++i)
         {
           for( j=0; j < 2; ++j )
           {
             matrix[i][j] = geoMatrix[i][j]/fieldSpacing[j];
           }
         }
       }
     }
     else if (VImageDimension == 3)
     {
       // Normal 3D image. Conversion possible without problem!
       for ( i=0; i < 3; ++i)
       {
         for( j=0; j < 3; ++j )
         {
           matrix[i][j] = geoMatrix[i][j]/fieldSpacing[j];
         }
       }
     }
     else
     {
       assert(0);
       throw mitk::AccessByItkException("Usage of resultGeometry for 2D images is not yet implemented.");
       /**@TODO Implement extraction of 2D-Rotation-Matrix out of 3D-Rotation-Matrix
       * to cover this case as well.
       * matrix = extract2DRotationMatrix(resultGeometry)*/
     }
 
     resultDescriptor->setOrigin(origin);
     resultDescriptor->setSize(size);
     resultDescriptor->setSpacing(fieldSpacing);
     resultDescriptor->setDirection(matrix);
   }
 
   //do the mapping
   /////////////////////////
   typedef ::itk::InterpolateImageFunction< ::itk::Image<TPixelType,VImageDimension> > BaseInterpolatorType;
   typename BaseInterpolatorType::Pointer interpolator = generateInterpolator< ::itk::Image<TPixelType,VImageDimension> >(interpolatorType);
   assert(interpolator.IsNotNull());
   spTask->setImageInterpolator(interpolator);
   spTask->setInputImage(input);
   spTask->setRegistration(castedReg);
   spTask->setResultImageDescriptor(resultDescriptor);
   spTask->setThrowOnMappingError(throwOnMappingError);
   spTask->setErrorValue(errorValue);
   spTask->setThrowOnPaddingError(throwOnOutOfInputAreaError);
   spTask->setPaddingValue(paddingValue);
 
   spTask->execute();
   mitk::CastToMitkImage<>(spTask->getResultImage(),result);
 }
 
 
 /**Helper function to ensure the mapping of all time steps of an image.*/
 void doMapTimesteps(const mitk::ImageMappingHelper::InputImageType* input, mitk::Image* result, const mitk::ImageMappingHelper::RegistrationType* registration, bool throwOnOutOfInputAreaError,double paddingValue, const mitk::ImageMappingHelper::ResultImageGeometryType* resultGeometry, bool throwOnMappingError, double errorValue, mitk::ImageMappingInterpolator::Type interpolatorType)
 {
   for (unsigned int i = 0; i<input->GetTimeSteps(); ++i)
   {
     mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
     imageTimeSelector->SetInput(input);
     imageTimeSelector->SetTimeNr(i);
     imageTimeSelector->UpdateLargestPossibleRegion();
 
     mitk::ImageMappingHelper::InputImageType::Pointer timeStepInput = imageTimeSelector->GetOutput();
     mitk::ImageMappingHelper::ResultImageType::Pointer timeStepResult;
     AccessByItk_n(timeStepInput, doMITKMap, (timeStepResult, registration, throwOnOutOfInputAreaError, paddingValue, resultGeometry, throwOnMappingError, errorValue, interpolatorType));
     mitk::ImageReadAccessor readAccess(timeStepResult);
     result->SetVolume(readAccess.GetData(), i);
   }
 }
 
 mitk::TimeGeometry::Pointer CreateResultTimeGeometry(const mitk::ImageMappingHelper::InputImageType* input, const mitk::ImageMappingHelper::ResultImageGeometryType* resultGeometry)
 {
   mitk::TimeGeometry::ConstPointer timeGeometry = input->GetTimeGeometry();
   mitk::TimeGeometry::Pointer mappedTimeGeometry = timeGeometry->Clone();
 
   for (unsigned int i = 0; i < input->GetTimeSteps(); ++i)
   {
     mitk::ImageMappingHelper::ResultImageGeometryType::Pointer mappedGeometry = resultGeometry->Clone();
     mappedTimeGeometry->SetTimeStepGeometry(mappedGeometry, i);
   }
   return mappedTimeGeometry;
 }
 
 mitk::ImageMappingHelper::ResultImageType::Pointer
   mitk::ImageMappingHelper::map(const InputImageType* input, const RegistrationType* registration,
   bool throwOnOutOfInputAreaError, const double& paddingValue, const ResultImageGeometryType* resultGeometry,
   bool throwOnMappingError, const double& errorValue, mitk::ImageMappingInterpolator::Type interpolatorType)
 {
   if (!registration)
   {
     mitkThrow() << "Cannot map image. Passed registration wrapper pointer is nullptr.";
   }
   if (!input)
   {
     mitkThrow() << "Cannot map image. Passed image pointer is nullptr.";
   }
 
   ResultImageType::Pointer result;
 
   auto inputLabelSetImage = dynamic_cast<const LabelSetImage*>(input);
 
   if (nullptr == inputLabelSetImage)
   {
     if (input->GetTimeSteps() == 1)
     { //map the image and done
       AccessByItk_n(input, doMITKMap, (result, registration, throwOnOutOfInputAreaError, paddingValue, resultGeometry, throwOnMappingError, errorValue, interpolatorType));
     }
     else
     { //map every time step and compose
 
       auto mappedTimeGeometry = CreateResultTimeGeometry(input, resultGeometry);
       result = mitk::Image::New();
       result->Initialize(input->GetPixelType(), *mappedTimeGeometry, 1, input->GetTimeSteps());
 
       doMapTimesteps(input, result, registration, throwOnOutOfInputAreaError, paddingValue, resultGeometry, throwOnMappingError, errorValue, interpolatorType);
     }
   }
   else
   {
     auto resultLabelSetImage = LabelSetImage::New();
 
     auto mappedTimeGeometry = CreateResultTimeGeometry(input, resultGeometry);
 
     auto resultTemplate = mitk::Image::New();
     resultTemplate->Initialize(input->GetPixelType(), *mappedTimeGeometry, 1, input->GetTimeSteps());
 
     resultLabelSetImage->Initialize(resultTemplate);
 
     auto cloneInput = inputLabelSetImage->Clone();
     //We need to clone the LabelSetImage due to its illposed design. It is state full
     //and we have to iterate through all layers as active layers to ensure the content
-    //via realy stored (directly working with the layer images does not work with the
-    //active layer. The clone wastes rescources but is the easiest and safest way to
+    //was really stored (directly working with the layer images does not work with the
+    //active layer). The clone wastes rescources but is the easiest and safest way to
     //ensure 1) correct mapping 2) avoid race conditions with other parts of the
     //application because we would change the state of the input.
     //This whole code block should be reworked as soon as T28525 is done.
 
     for (unsigned int layerID = 0; layerID < inputLabelSetImage->GetNumberOfLayers(); ++layerID)
     {
       if (resultLabelSetImage->GetNumberOfLayers() <= layerID)
       {
         resultLabelSetImage->AddLayer();
       }
       resultLabelSetImage->AddLabelSetToLayer(layerID, inputLabelSetImage->GetLabelSet(layerID)->Clone());
       cloneInput->SetActiveLayer(layerID);
       resultLabelSetImage->SetActiveLayer(layerID);
 
       doMapTimesteps(cloneInput, resultLabelSetImage, registration, throwOnOutOfInputAreaError, paddingValue, resultGeometry, throwOnMappingError, errorValue, mitk::ImageMappingInterpolator::Linear);
     }
 
     resultLabelSetImage->SetActiveLayer(inputLabelSetImage->GetActiveLayer());
     resultLabelSetImage->GetLabelSet(inputLabelSetImage->GetActiveLayer())->SetActiveLabel(inputLabelSetImage->GetActiveLabel(inputLabelSetImage->GetActiveLayer())->GetValue());
     result = resultLabelSetImage;
   }
 
   return result;
 }
 
 mitk::ImageMappingHelper::ResultImageType::Pointer
   mitk::ImageMappingHelper::map(const InputImageType* input, const MITKRegistrationType* registration,
   bool throwOnOutOfInputAreaError, const double& paddingValue, const ResultImageGeometryType* resultGeometry,
   bool throwOnMappingError, const double& errorValue, mitk::ImageMappingInterpolator::Type)
 {
   if (!registration)
   {
     mitkThrow() << "Cannot map image. Passed registration wrapper pointer is nullptr.";
   }
   if (!registration->GetRegistration())
   {
     mitkThrow() << "Cannot map image. Passed registration wrapper containes no registration.";
   }
   if (!input)
   {
     mitkThrow() << "Cannot map image. Passed image pointer is nullptr.";
   }
 
   ResultImageType::Pointer result = map(input, registration->GetRegistration(), throwOnOutOfInputAreaError, paddingValue, resultGeometry, throwOnMappingError, errorValue);
   return result;
 }
 
 
 mitk::ImageMappingHelper::ResultImageType::Pointer
   mitk::ImageMappingHelper::
   refineGeometry(const InputImageType* input, const RegistrationType* registration,
   bool throwOnError)
 {
   mitk::ImageMappingHelper::ResultImageType::Pointer result = nullptr;
 
   if (!registration)
   {
     mitkThrow() << "Cannot refine image geometry. Passed registration pointer is nullptr.";
   }
   if (!input)
   {
     mitkThrow() << "Cannot refine image geometry. Passed image pointer is nullptr.";
   }
 
   mitk::MITKRegistrationHelper::Affine3DTransformType::Pointer spTransform = mitk::MITKRegistrationHelper::getAffineMatrix(registration,false);
   if(spTransform.IsNull() && throwOnError)
   {
     mitkThrow() << "Cannot refine image geometry. Registration does not contain a suitable direct mapping kernel (3D affine transformation or compatible required).";
   }
 
   if(spTransform.IsNotNull())
   {
     //copy input image
     result = input->Clone();
 
     //refine geometries
     for(unsigned int i = 0; i < result->GetTimeSteps(); ++i)
     { //refine every time step
       result->GetGeometry(i)->Compose(spTransform);
     }
     result->GetTimeGeometry()->Update();
   }
 
   return result;
 }
 
 mitk::ImageMappingHelper::ResultImageType::Pointer
   mitk::ImageMappingHelper::
   refineGeometry(const InputImageType* input, const MITKRegistrationType* registration,
   bool throwOnError)
 {
   if (!registration)
   {
     mitkThrow() << "Cannot refine image geometry. Passed registration wrapper pointer is nullptr.";
   }
   if (!registration->GetRegistration())
   {
     mitkThrow() << "Cannot refine image geometry. Passed registration wrapper containes no registration.";
   }
   if (!input)
   {
     mitkThrow() << "Cannot refine image geometry. Passed image pointer is nullptr.";
   }
 
   ResultImageType::Pointer result = refineGeometry(input, registration->GetRegistration(), throwOnError);
   return result;
 }
 
 bool
   mitk::ImageMappingHelper::
   canRefineGeometry(const RegistrationType* registration)
 {
   bool result = true;
 
   if (!registration)
   {
     mitkThrow() << "Cannot check refine capability of registration. Passed registration pointer is nullptr.";
   }
 
   //if the helper does not return null, we can refine the geometry.
   result = mitk::MITKRegistrationHelper::getAffineMatrix(registration,false).IsNotNull();
 
   return result;
 }
 
 bool
   mitk::ImageMappingHelper::
   canRefineGeometry(const MITKRegistrationType* registration)
 {
   if (!registration)
   {
     mitkThrow() << "Cannot check refine capability of registration. Passed registration wrapper pointer is nullptr.";
   }
   if (!registration->GetRegistration())
   {
     mitkThrow() << "Cannot check refine capability of registration. Passed registration wrapper containes no registration.";
   }
 
   return canRefineGeometry(registration->GetRegistration());
 }
 
diff --git a/Modules/MatchPointRegistration/src/Rendering/mitkRegEvaluationMapper2D.cpp b/Modules/MatchPointRegistration/src/Rendering/mitkRegEvaluationMapper2D.cpp
index a2938eb0c8..fafaf04fb8 100644
--- a/Modules/MatchPointRegistration/src/Rendering/mitkRegEvaluationMapper2D.cpp
+++ b/Modules/MatchPointRegistration/src/Rendering/mitkRegEvaluationMapper2D.cpp
@@ -1,836 +1,836 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 //MITK
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkDataNode.h>
 #include <mitkImageSliceSelector.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkProperties.h>
 #include <mitkResliceMethodProperty.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 #include <mitkPixelType.h>
 #include <mitkTransferFunctionProperty.h>
 #include "mitkImageStatisticsHolder.h"
 #include "mitkPlaneClipping.h"
 
 #include "mitkRegVisPropertyTags.h"
 #include "mitkRegVisHelper.h"
 #include "mitkRegEvalStyleProperty.h"
 #include "mitkRegEvalWipeStyleProperty.h"
 
 //MITK Rendering
 #include "mitkRegEvaluationMapper2D.h"
 #include "vtkMitkThickSlicesFilter.h"
 #include "vtkMitkLevelWindowFilter.h"
 #include "vtkNeverTranslucentTexture.h"
 
 //VTK
 #include <vtkProperty.h>
 #include <vtkTransform.h>
 #include <vtkMatrix4x4.h>
 #include <vtkLookupTable.h>
 #include <vtkImageData.h>
 #include <vtkPoints.h>
 #include <vtkGeneralTransform.h>
 #include <vtkImageExtractComponents.h>
 #include <vtkImageReslice.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkPlaneSource.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkCellArray.h>
 #include <vtkCamera.h>
 #include <vtkColorTransferFunction.h>
 #include <vtkImageCheckerboard.h>
 #include <vtkImageWeightedSum.h>
 #include <vtkImageMathematics.h>
 #include <vtkImageRectilinearWipe.h>
 #include <vtkImageGradientMagnitude.h>
 #include <vtkImageAppendComponents.h>
 #include <vtkImageExtractComponents.h>
 
 //ITK
 #include <itkRGBAPixel.h>
 #include <mitkRenderingModeProperty.h>
 
 //MatchPoint
 #include <mitkRegEvaluationObject.h>
 #include <mitkImageMappingHelper.h>
 
 mitk::RegEvaluationMapper2D::RegEvaluationMapper2D()
 {
 }
 
 mitk::RegEvaluationMapper2D::~RegEvaluationMapper2D()
 {
 }
 
 //set the two points defining the textured plane according to the dimension and spacing
 void mitk::RegEvaluationMapper2D::GeneratePlane(mitk::BaseRenderer* renderer, double planeBounds[6])
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   float depth = this->CalculateLayerDepth(renderer);
   //Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
   //plane size in crosshair rotation and swivel mode.
   localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
   //These two points define the axes of the plane in combination with the origin.
   //Point 1 is the x-axis and point 2 the y-axis.
-  //Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
+  //Each plane is transformed according to the view (axial, coronal and sagittal) afterwards.
   localStorage->m_Plane->SetPoint1(planeBounds[1] , planeBounds[2], depth); //P1: (xMax, yMin, depth)
   localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); //P2: (xMin, yMax, depth)
 }
 
 float mitk::RegEvaluationMapper2D::CalculateLayerDepth(mitk::BaseRenderer* renderer)
 {
   //get the clipping range to check how deep into z direction we can render images
   double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
 
   //Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
   float depth = -maxRange*0.01; // divide by 100
   int layer = 0;
   GetDataNode()->GetIntProperty( "layer", layer, renderer);
   //add the layer property for each image to render images with a higher layer on top of the others
   depth += layer*10; //*10: keep some room for each image (e.g. for ODFs in between)
   if(depth > 0.0f) {
     depth = 0.0f;
     MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
   }
   return depth;
 }
 
 const mitk::Image* mitk::RegEvaluationMapper2D::GetTargetImage( void )
 {
   const mitk::RegEvaluationObject* evalObj = dynamic_cast< const mitk::RegEvaluationObject* >( GetDataNode()->GetData() );
   if (evalObj)
   {
     return evalObj->GetTargetImage();
   }
 
   return nullptr;
 }
 
 const mitk::Image* mitk::RegEvaluationMapper2D::GetMovingImage( void )
 {
   const mitk::RegEvaluationObject* evalObj = dynamic_cast< const mitk::RegEvaluationObject* >( GetDataNode()->GetData() );
   if (evalObj)
   {
     return evalObj->GetMovingImage();
   }
 
   return nullptr;
 }
 
 const mitk::DataNode* mitk::RegEvaluationMapper2D::GetTargetNode(void)
 {
   const mitk::RegEvaluationObject* evalObj = dynamic_cast< const mitk::RegEvaluationObject* >(GetDataNode()->GetData());
   if (evalObj)
   {
     return evalObj->GetTargetNode();
   }
 
   return nullptr;
 }
 
 const mitk::DataNode* mitk::RegEvaluationMapper2D::GetMovingNode(void)
 {
   const mitk::RegEvaluationObject* evalObj = dynamic_cast< const mitk::RegEvaluationObject* >(GetDataNode()->GetData());
   if (evalObj)
   {
     return evalObj->GetMovingNode();
   }
 
   return nullptr;
 }
 
 const mitk::MAPRegistrationWrapper* mitk::RegEvaluationMapper2D::GetRegistration( void )
 {
   const mitk::RegEvaluationObject* evalObj = dynamic_cast< const mitk::RegEvaluationObject* >( GetDataNode()->GetData() );
   if (evalObj)
   {
     return evalObj->GetRegistration();
   }
 
   return nullptr;
 }
 
 vtkProp* mitk::RegEvaluationMapper2D::GetVtkProp(mitk::BaseRenderer* renderer)
 {
   //return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Actors;
 }
 
 void mitk::RegEvaluationMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   bool updated = false;
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   mitk::Image::Pointer targetInput = const_cast< mitk::Image * >( this->GetTargetImage() );
   mitk::DataNode* datanode = this->GetDataNode();
 
   if ( targetInput.IsNull() || targetInput->IsInitialized() == false )
   {
     return;
   }
 
   mitk::Image::ConstPointer movingInput = this->GetMovingImage();
 
   if ( movingInput.IsNull() || movingInput->IsInitialized() == false )
   {
     return;
   }
 
   mitk::MAPRegistrationWrapper::ConstPointer reg = this->GetRegistration();
 
   //check if there is a valid worldGeometry
   const PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
   if( ( worldGeometry == nullptr ) || ( !worldGeometry->IsValid() ) || ( !worldGeometry->HasReferenceGeometry() ))
   {
     return;
   }
 
   if(targetInput->GetMTime()>localStorage->m_LastUpdateTime
     || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) //was the geometry modified?
     || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()))
   { //target input has been modified -> reslice target input
     targetInput->Update();
 
     // early out if there is no intersection of the current rendering geometry
     // and the geometry of the image that is to be rendered.
     if ( !RenderingGeometryIntersectsImage( worldGeometry, targetInput->GetSlicedGeometry() ) )
     {
       // set image to nullptr, to clear the texture in 3D, because
       // the latest image is used there if the plane is out of the geometry
       // see bug-13275
       localStorage->m_EvaluationImage = nullptr;
       localStorage->m_Mapper->SetInputData( localStorage->m_EmptyPolyData );
       return;
     }
 
     //set main input for ExtractSliceFilter
     localStorage->m_Reslicer->SetInput(targetInput);
     localStorage->m_Reslicer->SetWorldGeometry(worldGeometry);
     localStorage->m_Reslicer->SetTimeStep( this->GetTimestep() );
 
 
     //set the transformation of the image to adapt reslice axis
     localStorage->m_Reslicer->SetResliceTransformByGeometry( targetInput->GetTimeGeometry()->GetGeometryForTimeStep( this->GetTimestep() ) );
 
 
     //is the geometry of the slice based on the input image or the worldgeometry?
     bool inPlaneResampleExtentByGeometry = false;
     datanode->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
     localStorage->m_Reslicer->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
 
 
     // Initialize the interpolation mode for resampling; switch to nearest
     // neighbor if the input image is too small.
     if ( (targetInput->GetDimension() >= 3) && (targetInput->GetDimension(2) > 1) )
     {
       VtkResliceInterpolationProperty *resliceInterpolationProperty;
       datanode->GetProperty(
         resliceInterpolationProperty, "reslice interpolation" );
 
       int interpolationMode = VTK_RESLICE_NEAREST;
       if ( resliceInterpolationProperty != nullptr )
       {
         interpolationMode = resliceInterpolationProperty->GetInterpolation();
       }
 
       switch ( interpolationMode )
       {
       case VTK_RESLICE_NEAREST:
         localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
         break;
       case VTK_RESLICE_LINEAR:
         localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_LINEAR);
         break;
       case VTK_RESLICE_CUBIC:
         localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_CUBIC);
         break;
       }
     }
     else
     {
       localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
     }
 
     //this is needed when thick mode was enable bevore. These variable have to be reset to default values
     localStorage->m_Reslicer->SetOutputDimensionality( 2 );
     localStorage->m_Reslicer->SetOutputSpacingZDirection(1.0);
     localStorage->m_Reslicer->SetOutputExtentZDirection( 0, 0 );
 
     localStorage->m_Reslicer->Modified();
     //start the pipeline with updating the largest possible, needed if the geometry of the input has changed
     localStorage->m_Reslicer->UpdateLargestPossibleRegion();
     localStorage->m_slicedTargetImage = localStorage->m_Reslicer->GetOutput();
     updated = true;
   }
 
   if(updated ||
     movingInput->GetMTime() > localStorage->m_LastUpdateTime ||
     reg->GetMTime() > localStorage->m_LastUpdateTime)
   {
     //Map moving image
     localStorage->m_slicedMappedImage = mitk::ImageMappingHelper::map(movingInput,reg,false,0,localStorage->m_slicedTargetImage->GetGeometry(),false,0);
     updated = true;
   }
 
   // Bounds information for reslicing (only required if reference geometry
   // is present)
   //this used for generating a vtkPLaneSource with the right size
   double sliceBounds[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
 
   if (updated
     || (localStorage->m_LastUpdateTime < datanode->GetPropertyList()->GetMTime()) //was a property modified?
     || (localStorage->m_LastUpdateTime < datanode->GetPropertyList(renderer)->GetMTime())
     || (localStorage->m_LastUpdateTime < this->GetTargetNode()->GetMTime())
     || (localStorage->m_LastUpdateTime < this->GetMovingNode()->GetMTime()))
   {
     localStorage->m_Reslicer->GetClippedPlaneBounds(sliceBounds);
 
     //get the spacing of the slice
     localStorage->m_mmPerPixel = localStorage->m_Reslicer->GetOutputSpacing();
 
     // calculate minimum bounding rect of IMAGE in texture
     {
       double textureClippingBounds[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
 
       // Calculate the actual bounds of the transformed plane clipped by the
       // dataset bounding box; this is required for drawing the texture at the
       // correct position during 3D mapping.
 
       const PlaneGeometry *planeGeometry = dynamic_cast<const PlaneGeometry *>(worldGeometry);
       mitk::PlaneClipping::CalculateClippedPlaneBounds(targetInput->GetGeometry(), planeGeometry, textureClippingBounds);
 
       textureClippingBounds[0] = static_cast<int>(textureClippingBounds[0] / localStorage->m_mmPerPixel[0] + 0.5);
       textureClippingBounds[1] = static_cast<int>(textureClippingBounds[1] / localStorage->m_mmPerPixel[0] + 0.5);
       textureClippingBounds[2] = static_cast<int>(textureClippingBounds[2] / localStorage->m_mmPerPixel[1] + 0.5);
       textureClippingBounds[3] = static_cast<int>(textureClippingBounds[3] / localStorage->m_mmPerPixel[1] + 0.5);
 
       //clipping bounds for cutting the image
       localStorage->m_TargetLevelWindowFilter->SetClippingBounds(textureClippingBounds);
       localStorage->m_MappedLevelWindowFilter->SetClippingBounds(textureClippingBounds);
     }
 
     this->ApplyLookuptable(renderer, this->GetTargetNode(), localStorage->m_TargetLevelWindowFilter);
     this->ApplyLookuptable(renderer, this->GetMovingNode(), localStorage->m_MappedLevelWindowFilter);
     this->ApplyLevelWindow(renderer, this->GetTargetNode(), localStorage->m_TargetLevelWindowFilter);
     this->ApplyLevelWindow(renderer, this->GetMovingNode(), localStorage->m_MappedLevelWindowFilter);
 
     //connect the input with the levelwindow filter
     localStorage->m_TargetLevelWindowFilter->SetInputData(localStorage->m_slicedTargetImage->GetVtkImageData());
     localStorage->m_MappedLevelWindowFilter->SetInputData(localStorage->m_slicedMappedImage->GetVtkImageData());
 
     localStorage->m_TargetExtractFilter->SetInputConnection(localStorage->m_TargetLevelWindowFilter->GetOutputPort());
     localStorage->m_MappedExtractFilter->SetInputConnection(localStorage->m_MappedLevelWindowFilter->GetOutputPort());
     localStorage->m_TargetExtractFilter->SetComponents(0);
     localStorage->m_MappedExtractFilter->SetComponents(0);
 
     updated = true;
   }
 
   //Generate evaluation image
   bool isStyleOutdated = mitk::PropertyIsOutdated(datanode,mitk::nodeProp_RegEvalStyle,localStorage->m_LastUpdateTime);
   bool isBlendOutdated = mitk::PropertyIsOutdated(datanode,mitk::nodeProp_RegEvalBlendFactor,localStorage->m_LastUpdateTime);
   bool isCheckerOutdated = mitk::PropertyIsOutdated(datanode,mitk::nodeProp_RegEvalCheckerCount,localStorage->m_LastUpdateTime);
   bool isWipeStyleOutdated = mitk::PropertyIsOutdated(datanode,mitk::nodeProp_RegEvalWipeStyle,localStorage->m_LastUpdateTime);
   bool isContourOutdated = mitk::PropertyIsOutdated(datanode,mitk::nodeProp_RegEvalTargetContour,localStorage->m_LastUpdateTime);
   bool isPositionOutdated = mitk::PropertyIsOutdated(datanode, mitk::nodeProp_RegEvalCurrentPosition, localStorage->m_LastUpdateTime);
 
   if (updated ||
     isStyleOutdated ||
     isBlendOutdated ||
     isCheckerOutdated ||
     isWipeStyleOutdated ||
     isContourOutdated ||
     isPositionOutdated)
   {
     mitk::RegEvalStyleProperty::Pointer evalStyleProp = mitk::RegEvalStyleProperty::New();
     datanode->GetProperty(evalStyleProp, mitk::nodeProp_RegEvalStyle);
 
     switch (evalStyleProp->GetValueAsId())
     {
     case 0 :
       {
         PrepareBlend(datanode, localStorage);
         break;
       }
     case 1 :
       {
         PrepareColorBlend(localStorage);
         break;
       }
     case 2 :
       {
         PrepareCheckerBoard(datanode, localStorage);
         break;
       }
     case 3 :
       {
         const PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
 
         Point3D currentPos3D;
         datanode->GetPropertyValue<Point3D>(mitk::nodeProp_RegEvalCurrentPosition, currentPos3D);
 
         Point2D currentPos2D;
         worldGeometry->Map(currentPos3D, currentPos2D);
         Point2D currentIndex2D;
         worldGeometry->WorldToIndex(currentPos2D, currentIndex2D);
 
         PrepareWipe(datanode, localStorage, currentIndex2D);
         break;
       }
     case 4 :
       {
         PrepareDifference(localStorage);
         break;
       }
     case 5 :
       {
         PrepareContour(datanode, localStorage);
         break;
       }
     }
     updated = true;
   }
 
   if(updated
     || (localStorage->m_LastUpdateTime < datanode->GetPropertyList()->GetMTime()) //was a property modified?
     || (localStorage->m_LastUpdateTime < datanode->GetPropertyList(renderer)->GetMTime()) )
   {
     this->ApplyOpacity( renderer );
 
     // do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
     localStorage->m_Texture->SetColorModeToDirectScalars();
 
     // check for texture interpolation property
     bool textureInterpolation = false;
     GetDataNode()->GetBoolProperty( "texture interpolation", textureInterpolation, renderer );
 
     //set the interpolation modus according to the property
     localStorage->m_Texture->SetInterpolate(textureInterpolation);
 
     // connect the texture with the output of the levelwindow filter
     localStorage->m_Texture->SetInputData(localStorage->m_EvaluationImage);
 
     this->TransformActor( renderer );
 
     vtkActor* contourShadowActor = dynamic_cast<vtkActor*> (localStorage->m_Actors->GetParts()->GetItemAsObject(0));
 
     //Connect the mapper with the input texture. This is the standard case.
     //setup the textured plane
     this->GeneratePlane( renderer, sliceBounds );
     //set the plane as input for the mapper
     localStorage->m_Mapper->SetInputConnection(localStorage->m_Plane->GetOutputPort());
     //set the texture for the actor
 
     localStorage->m_Actor->SetTexture(localStorage->m_Texture);
     contourShadowActor->SetVisibility( false );
 
     // We have been modified => save this for next Update()
     localStorage->m_LastUpdateTime.Modified();
   }
 }
 
 
 void mitk::RegEvaluationMapper2D::PrepareContour( mitk::DataNode* datanode, LocalStorage * localStorage )
 {
   bool targetContour = true;
   datanode->GetBoolProperty(mitk::nodeProp_RegEvalTargetContour,targetContour);
 
   vtkSmartPointer<vtkImageGradientMagnitude> magFilter =
     vtkSmartPointer<vtkImageGradientMagnitude>::New();
 
   if(targetContour)
   {
     magFilter->SetInputConnection(localStorage->m_TargetExtractFilter->GetOutputPort());
   }
   else
   {
     magFilter->SetInputConnection(localStorage->m_MappedExtractFilter->GetOutputPort());
   }
 
   vtkSmartPointer<vtkImageAppendComponents> appendFilter =
     vtkSmartPointer<vtkImageAppendComponents>::New();
 
   appendFilter->AddInputConnection(magFilter->GetOutputPort());
   appendFilter->AddInputConnection(magFilter->GetOutputPort());
   if(targetContour)
   {
     appendFilter->AddInputConnection(localStorage->m_MappedExtractFilter->GetOutputPort());
   }
   else
   {
     appendFilter->AddInputConnection(localStorage->m_TargetExtractFilter->GetOutputPort());
   }
   appendFilter->Update();
 
   localStorage->m_EvaluationImage = appendFilter->GetOutput();
 }
 
 void mitk::RegEvaluationMapper2D::PrepareDifference( LocalStorage * localStorage )
 {
   vtkSmartPointer<vtkImageMathematics> diffFilter =
     vtkSmartPointer<vtkImageMathematics>::New();
   vtkSmartPointer<vtkImageMathematics> minFilter =
     vtkSmartPointer<vtkImageMathematics>::New();
   vtkSmartPointer<vtkImageMathematics> maxFilter =
     vtkSmartPointer<vtkImageMathematics>::New();
 
   minFilter->SetInputConnection(0, localStorage->m_TargetExtractFilter->GetOutputPort());
   minFilter->SetInputConnection(1, localStorage->m_MappedExtractFilter->GetOutputPort());
   minFilter->SetOperationToMin();
   maxFilter->SetInputConnection(0, localStorage->m_TargetExtractFilter->GetOutputPort());
   maxFilter->SetInputConnection(1, localStorage->m_MappedExtractFilter->GetOutputPort());
   maxFilter->SetOperationToMax();
 
   diffFilter->SetInputConnection(0, maxFilter->GetOutputPort());
   diffFilter->SetInputConnection(1, minFilter->GetOutputPort());
   diffFilter->SetOperationToSubtract();
   diffFilter->Update();
   localStorage->m_EvaluationImage = diffFilter->GetOutput();
 }
 
 void mitk::RegEvaluationMapper2D::PrepareWipe(mitk::DataNode* datanode, LocalStorage * localStorage, const Point2D& currentIndex2D)
 {
   mitk::RegEvalWipeStyleProperty::Pointer evalWipeStyleProp = mitk::RegEvalWipeStyleProperty::New();
   datanode->GetProperty(evalWipeStyleProp, mitk::nodeProp_RegEvalWipeStyle);
 
   vtkSmartPointer<vtkImageRectilinearWipe> wipedFilter =
     vtkSmartPointer<vtkImageRectilinearWipe>::New();
   wipedFilter->SetInputConnection(0, localStorage->m_TargetLevelWindowFilter->GetOutputPort());
   wipedFilter->SetInputConnection(1, localStorage->m_MappedLevelWindowFilter->GetOutputPort());
   wipedFilter->SetPosition(currentIndex2D[0], currentIndex2D[1]);
 
   if (evalWipeStyleProp->GetValueAsId() == 0)
   {
     wipedFilter->SetWipeToQuad();
   }
   else if (evalWipeStyleProp->GetValueAsId() == 1)
   {
     wipedFilter->SetWipeToHorizontal();
   }
   else if (evalWipeStyleProp->GetValueAsId() == 2)
   {
     wipedFilter->SetWipeToVertical();
   }
 
   wipedFilter->Update();
 
   localStorage->m_EvaluationImage = wipedFilter->GetOutput();
 }
 
 void mitk::RegEvaluationMapper2D::PrepareCheckerBoard( mitk::DataNode* datanode, LocalStorage * localStorage )
 {
   int checkerCount = 5;
   datanode->GetIntProperty(mitk::nodeProp_RegEvalCheckerCount,checkerCount);
 
   vtkSmartPointer<vtkImageCheckerboard> checkerboardFilter =
     vtkSmartPointer<vtkImageCheckerboard>::New();
   checkerboardFilter->SetInputConnection(0, localStorage->m_TargetLevelWindowFilter->GetOutputPort());
   checkerboardFilter->SetInputConnection(1, localStorage->m_MappedLevelWindowFilter->GetOutputPort());
   checkerboardFilter->SetNumberOfDivisions(checkerCount, checkerCount, 1);
   checkerboardFilter->Update();
 
   localStorage->m_EvaluationImage = checkerboardFilter->GetOutput();
 }
 
 void mitk::RegEvaluationMapper2D::PrepareColorBlend( LocalStorage * localStorage )
 {
   vtkSmartPointer<vtkImageAppendComponents> appendFilter =
     vtkSmartPointer<vtkImageAppendComponents>::New();
 
   //red channel
   appendFilter->AddInputConnection(localStorage->m_MappedExtractFilter->GetOutputPort());
   //green channel
   appendFilter->AddInputConnection(localStorage->m_MappedExtractFilter->GetOutputPort());
 
   //blue channel
   appendFilter->AddInputConnection(localStorage->m_TargetExtractFilter->GetOutputPort());
   appendFilter->Update();
 
   localStorage->m_EvaluationImage = appendFilter->GetOutput();
 }
 
 void mitk::RegEvaluationMapper2D::PrepareBlend( mitk::DataNode* datanode, LocalStorage * localStorage )
 {
   int blendfactor = 50;
   datanode->GetIntProperty(mitk::nodeProp_RegEvalBlendFactor,blendfactor);
 
   vtkSmartPointer<vtkImageWeightedSum> blendFilter =
     vtkSmartPointer<vtkImageWeightedSum>::New();
 
   blendFilter->AddInputConnection(localStorage->m_TargetExtractFilter->GetOutputPort());
   blendFilter->AddInputConnection(localStorage->m_MappedExtractFilter->GetOutputPort());
   blendFilter->SetWeight(0, (100 - blendfactor) / 100.);
   blendFilter->SetWeight(1,blendfactor/100.);
   blendFilter->Update();
 
   localStorage->m_EvaluationImage = blendFilter->GetOutput();
 }
 
 void mitk::RegEvaluationMapper2D::ApplyLevelWindow(mitk::BaseRenderer *renderer, const mitk::DataNode* dataNode, vtkMitkLevelWindowFilter* levelFilter)
 {
   LevelWindow levelWindow;
   dataNode->GetLevelWindow(levelWindow, renderer, "levelwindow");
   levelFilter->GetLookupTable()->SetRange(levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound());
 
   mitk::LevelWindow opacLevelWindow;
   if (dataNode->GetLevelWindow(opacLevelWindow, renderer, "opaclevelwindow"))
   {
     //pass the opaque level window to the filter
     levelFilter->SetMinOpacity(opacLevelWindow.GetLowerWindowBound());
     levelFilter->SetMaxOpacity(opacLevelWindow.GetUpperWindowBound());
   }
   else
   {
     //no opaque level window
     levelFilter->SetMinOpacity(0.0);
     levelFilter->SetMaxOpacity(255.0);
   }
 }
 
 void mitk::RegEvaluationMapper2D::ApplyLookuptable(mitk::BaseRenderer* renderer, const mitk::DataNode* dataNode, vtkMitkLevelWindowFilter* levelFilter)
 {
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
   vtkLookupTable* usedLookupTable = localStorage->m_ColorLookupTable;
 
   // If lookup table or transferfunction use is requested...
   mitk::LookupTableProperty::Pointer lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(dataNode->GetProperty("LookupTable"));
 
   if (lookupTableProp.IsNotNull()) // is a lookuptable set?
   {
     usedLookupTable = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
   }
   else
   {
     //"Image Rendering.Mode was set to use a lookup table but there is no property 'LookupTable'.
     //A default (rainbow) lookup table will be used.
     //Here have to do nothing. Warning for the user has been removed, due to unwanted console output
     //in every interation of the rendering.
   }
   levelFilter->SetLookupTable(usedLookupTable);
 }
 
 void mitk::RegEvaluationMapper2D::ApplyOpacity( mitk::BaseRenderer* renderer )
 {
   LocalStorage* localStorage = this->GetLocalStorage( renderer );
   float opacity = 1.0f;
   // check for opacity prop and use it for rendering if it exists
   GetDataNode()->GetOpacity( opacity, renderer, "opacity" );
   //set the opacity according to the properties
   localStorage->m_Actor->GetProperty()->SetOpacity(opacity);
   if ( localStorage->m_Actors->GetParts()->GetNumberOfItems() > 1 )
   {
     dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) )->GetProperty()->SetOpacity(opacity);
   }
 }
 
 void mitk::RegEvaluationMapper2D::Update(mitk::BaseRenderer* renderer)
 {
 
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible )
   {
     return;
   }
 
   mitk::Image* data  = const_cast<mitk::Image *>( this->GetTargetImage() );
   if ( data == nullptr )
   {
     return;
   }
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep( renderer );
 
   // Check if time step is valid
   const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ( ( dataTimeGeometry == nullptr )
     || ( dataTimeGeometry->CountTimeSteps() == 0 )
     || ( !dataTimeGeometry->IsValidTimeStep( this->GetTimestep() ) ) )
   {
     return;
   }
 
   const DataNode *node = this->GetDataNode();
   data->UpdateOutputInformation();
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   //check if something important has changed and we need to rerender
   if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
     || (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) //Was the data modified?
     || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) //was the geometry modified?
     || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime())
     || (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
     || (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime())
     || (localStorage->m_LastUpdateTime < this->GetTargetNode()->GetMTime()) //was the target node modified?
     || (localStorage->m_LastUpdateTime < this->GetMovingNode()->GetMTime()) //was the moving node modified?
     || (localStorage->m_LastUpdateTime < this->GetTargetNode()->GetPropertyList()->GetMTime()) //was a target node property modified?
     || (localStorage->m_LastUpdateTime < this->GetTargetNode()->GetPropertyList(renderer)->GetMTime())
     || (localStorage->m_LastUpdateTime < this->GetMovingNode()->GetPropertyList()->GetMTime()) //was a moving node property modified?
     || (localStorage->m_LastUpdateTime < this->GetMovingNode()->GetPropertyList(renderer)->GetMTime()))
   {
     this->GenerateDataForRenderer( renderer );
   }
 
   // since we have checked that nothing important has changed, we can set
   // m_LastUpdateTime to the current time
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::RegEvaluationMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   mitk::RegEvaluationObject* regEval = dynamic_cast<mitk::RegEvaluationObject*>(node->GetData());
 
   if(!regEval)
   {
     return;
   }
 
   // Properties common for both images and segmentations
   node->AddProperty( "depthOffset", mitk::FloatProperty::New( 0.0 ), renderer, overwrite );
   if(regEval->GetTargetImage() && regEval->GetTargetImage()->IsRotated()) node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_CUBIC) );
   else node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
   node->AddProperty( "texture interpolation", mitk::BoolProperty::New( false ) );  // set to user configurable default value (see global options)
   node->AddProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
   node->AddProperty( "bounding box", mitk::BoolProperty::New( false ) );
 
   mitk::RenderingModeProperty::Pointer renderingModeProperty = mitk::RenderingModeProperty::New();
   node->AddProperty( "Image Rendering.Mode", renderingModeProperty);
 
   // Set default grayscale look-up table
   mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
   mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
   mitkLutProp->SetLookupTable(mitkLut);
   node->SetProperty("LookupTable", mitkLutProp);
 
   node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
   node->AddProperty( "color", ColorProperty::New(1.0,1.0,1.0), renderer, overwrite );
   node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
 
   node->AddProperty(mitk::nodeProp_RegEvalStyle, mitk::RegEvalStyleProperty::New(0), renderer, overwrite);
   node->AddProperty(mitk::nodeProp_RegEvalBlendFactor, mitk::IntProperty::New(50), renderer, overwrite);
   node->AddProperty(mitk::nodeProp_RegEvalCheckerCount, mitk::IntProperty::New(3), renderer, overwrite);
   node->AddProperty(mitk::nodeProp_RegEvalTargetContour, mitk::BoolProperty::New(true), renderer, overwrite);
   node->AddProperty(mitk::nodeProp_RegEvalWipeStyle, mitk::RegEvalWipeStyleProperty::New(0), renderer, overwrite);
   node->AddProperty(mitk::nodeProp_RegEvalCurrentPosition, mitk::Point3dProperty::New(mitk::Point3D()), renderer, overwrite);
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 mitk::RegEvaluationMapper2D::LocalStorage* mitk::RegEvaluationMapper2D::GetLocalStorage(mitk::BaseRenderer* renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 void mitk::RegEvaluationMapper2D::TransformActor(mitk::BaseRenderer* renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
-  //get the transformation matrix of the reslicer in order to render the slice as axial, coronal or saggital
+  //get the transformation matrix of the reslicer in order to render the slice as axial, coronal or sagittal
   vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
   vtkSmartPointer<vtkMatrix4x4> matrix = localStorage->m_Reslicer->GetResliceAxes();
   trans->SetMatrix(matrix);
-  //transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or saggital)
+  //transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or sagittal)
   localStorage->m_Actor->SetUserTransform(trans);
   //transform the origin to center based coordinates, because MITK is center based.
   localStorage->m_Actor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
 
   if ( localStorage->m_Actors->GetNumberOfPaths() > 1 )
   {
     vtkActor* secondaryActor = dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) );
     secondaryActor->SetUserTransform(trans);
     secondaryActor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
   }
 }
 
 bool mitk::RegEvaluationMapper2D::RenderingGeometryIntersectsImage( const PlaneGeometry* renderingGeometry, SlicedGeometry3D* imageGeometry )
 {
   // if either one of the two geometries is nullptr we return true
   // for safety reasons
   if ( renderingGeometry == nullptr || imageGeometry == nullptr )
     return true;
 
   // get the distance for the first cornerpoint
   ScalarType initialDistance = renderingGeometry->SignedDistance( imageGeometry->GetCornerPoint( 0 ) );
   for( int i=1; i<8; i++ )
   {
     mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint( i );
 
     // get the distance to the other cornerpoints
     ScalarType distance = renderingGeometry->SignedDistance( cornerPoint );
 
     // if it has not the same signing as the distance of the first point
     if ( initialDistance * distance < 0 )
     {
       // we have an intersection and return true
       return true;
     }
   }
 
   // all distances have the same sign, no intersection and we return false
   return false;
 }
 
 mitk::RegEvaluationMapper2D::LocalStorage::~LocalStorage()
 {
 }
 
 mitk::RegEvaluationMapper2D::LocalStorage::LocalStorage()
 {
   m_TargetLevelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
   m_MappedLevelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
 
   m_TargetExtractFilter = vtkSmartPointer<vtkImageExtractComponents>::New();
   m_MappedExtractFilter = vtkSmartPointer<vtkImageExtractComponents>::New();
 
   m_mmPerPixel = nullptr;
 
   //Do as much actions as possible in here to avoid double executions.
   m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
   //m_Texture = vtkSmartPointer<vtkNeverTranslucentTexture>::New().GetPointer();
   m_Texture = vtkSmartPointer<vtkOpenGLTexture>::New().GetPointer();
   m_DefaultLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_ColorLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_Actor = vtkSmartPointer<vtkActor>::New();
   m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
   m_Reslicer = mitk::ExtractSliceFilter::New();
   m_EvaluationImage = vtkSmartPointer<vtkImageData>::New();
   m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
 
   mitk::LookupTable::Pointer mitkLUT = mitk::LookupTable::New();
   //built a default lookuptable
   mitkLUT->SetType(mitk::LookupTable::GRAYSCALE);
   m_DefaultLookupTable = mitkLUT->GetVtkLookupTable();
 
   mitkLUT->SetType(mitk::LookupTable::JET);
   m_ColorLookupTable = mitkLUT->GetVtkLookupTable();
 
   //do not repeat the texture (the image)
   m_Texture->RepeatOff();
 
   //set the mapper for the actor
   m_Actor->SetMapper( m_Mapper );
 
   vtkSmartPointer<vtkActor> outlineShadowActor = vtkSmartPointer<vtkActor>::New();
   outlineShadowActor->SetMapper( m_Mapper );
 
   m_Actors->AddPart( outlineShadowActor );
   m_Actors->AddPart( m_Actor );
 }
diff --git a/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegistrationManipulationWidget.h b/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegistrationManipulationWidget.h
index 11747ef3ee..e90dca3216 100644
--- a/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegistrationManipulationWidget.h
+++ b/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegistrationManipulationWidget.h
@@ -1,129 +1,128 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef __Q_MITK_REGISTRATION_MANIPULATION_WIDGET_H
 #define __Q_MITK_REGISTRATION_MANIPULATION_WIDGET_H
 
 
 #include <itkEuler3DTransform.h>
 #include "mapRegistration.h"
 #include "mapContinuous.h"
 
 #include <mitkPoint.h>
 
 #include <QWidget>
 
 #include <MitkMatchPointRegistrationUIExports.h>
 
 #include "ui_QmitkRegistrationManipulationWidget.h"
 
 
 /*!
 \brief QmitkMatchPointRegistrationManipulator
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
-\sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class MITKMATCHPOINTREGISTRATIONUI_EXPORT QmitkRegistrationManipulationWidget : public QWidget, private Ui::QmitkRegistrationManipulationWidget
 {
   Q_OBJECT
 
 public:
   QmitkRegistrationManipulationWidget(QWidget *parent = nullptr);
 
   ~QmitkRegistrationManipulationWidget() override;
 
   /** Type of transform that can be provided as preceding transform.*/
   typedef map::core::Registration<3, 3> MAPRegistrationType;
 
   /** Initializing/reset widget with identity transform.*/
   void Initialize();
 
   /** Initializing/reset widget with a preceding registration.*/
   void Initialize(MAPRegistrationType* precedingRegistration);
 
   /** Initializing/reset widget with an translation transform deduced by the to passed reference points.*/
   void Initialize(const mitk::Point3D& movingReference, const mitk::Point3D& targetReference);
 
   /**This function offers access to a registration instance that represents the internal state of the
   registration currently manipulated by the widget. It can be used for example to update the visualization.*/
   map::core::RegistrationBase* GetInterimRegistration() const;
 
   /**This function generates a new registration instance that resembles the state when the method was called.
   Ownership of the return goes to the caller.*/
   map::core::RegistrationBase::Pointer GenerateRegistration()const ;
 
 public Q_SLOTS:
   void SetCenterOfRotation(const mitk::Point3D& center);
 
   /** Sets the internal m_CenterOfRotationIsRelativeToTarget. see below.*/
   void SetCenterOfRotationIsRelativeToTarget(bool targetRelative);
 
 signals:
   void RegistrationChanged(map::core::RegistrationBase *registration);
 
 protected slots:
 
   void OnRotXChanged(double);
   void OnRotYChanged(double);
   void OnRotZChanged(double);
 
   void OnTransXChanged(double);
   void OnTransYChanged(double);
   void OnTransZChanged(double);
 
   void OnRotXSlideChanged(int);
   void OnRotYSlideChanged(int);
   void OnRotZSlideChanged(int);
 
   void OnTransXSlideChanged(int);
   void OnTransYSlideChanged(int);
   void OnTransZSlideChanged(int);
 
 private:
 
   /** Initializes/resets the transforms.*/
   void ResetTransforms();
   /** Initialize the sub widgets according to the internal state of the transforms.*/
   void InitControls();
 
   /**
   * Updates the widgets that manipulate the transform according to the transform.*/
   void UpdateTransformWidgets();
 
   /**
   * Updates the transform according to the widgets that manipulate the transform.*/
   void UpdateTransform(bool updateRotation = false);
 
   void ConfigureTransformCenter();
 
   MAPRegistrationType::Pointer m_PreRegistration;
 
   using TransformType = itk::Euler3DTransform<::map::core::continuous::ScalarType>;
   TransformType::Pointer m_InverseCurrentTransform;
   TransformType::Pointer m_DirectCurrentTransform;
 
   MAPRegistrationType::Pointer m_CurrentRegistration;
   mitk::Point3D m_CenterOfRotation;
   /** This flag indicates if the center of rotation is specified relative to the target
   (true; thus must be updated when the inverse transform is changed) or relative to the moving
   (false; thus must not be updated).*/
   bool m_CenterOfRotationIsRelativeToTarget;
 
   bool m_internalUpdate;
 };
 
 #endif // MatchPoint_h
 
diff --git a/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegistrationManipulationWidget.ui b/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegistrationManipulationWidget.ui
index 3b21b89e32..f43f20ac0c 100644
--- a/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegistrationManipulationWidget.ui
+++ b/Modules/MatchPointRegistrationUI/Qmitk/QmitkRegistrationManipulationWidget.ui
@@ -1,623 +1,623 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkRegistrationManipulationWidget</class>
  <widget class="QWidget" name="QmitkRegistrationManipulationWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>379</width>
     <height>317</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="spacing">
     <number>5</number>
    </property>
    <property name="leftMargin">
     <number>5</number>
    </property>
    <property name="topMargin">
     <number>5</number>
    </property>
    <property name="rightMargin">
     <number>5</number>
    </property>
    <property name="bottomMargin">
     <number>5</number>
    </property>
    <item>
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Translation</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <property name="leftMargin">
        <number>6</number>
       </property>
       <property name="topMargin">
        <number>3</number>
       </property>
       <property name="rightMargin">
        <number>6</number>
       </property>
       <property name="bottomMargin">
        <number>3</number>
       </property>
       <item row="2" column="0">
        <widget class="QLabel" name="label_4">
         <property name="text">
          <string>y (Coronal)</string>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QLabel" name="label_2">
         <property name="text">
          <string>x (Sagittal)</string>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QLabel" name="label_3">
         <property name="text">
          <string>z (Axial)</string>
         </property>
        </widget>
       </item>
       <item row="3" column="1">
        <widget class="QSlider" name="slideTransZ">
         <property name="minimum">
          <number>-100</number>
         </property>
         <property name="maximum">
          <number>100</number>
         </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QSlider" name="slideTransY">
         <property name="minimum">
          <number>-100</number>
         </property>
         <property name="maximum">
          <number>100</number>
         </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QSlider" name="slideTransX">
         <property name="minimum">
          <number>-100</number>
         </property>
         <property name="maximum">
          <number>100</number>
         </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <widget class="QDoubleSpinBox" name="sbTransX">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>0</height>
          </size>
         </property>
         <property name="baseSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="styleSheet">
          <string notr="true">background-color: rgb(0, 170, 0)</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="suffix">
          <string> mm</string>
         </property>
         <property name="minimum">
          <double>-9999.000000000000000</double>
         </property>
         <property name="maximum">
          <double>9999.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.500000000000000</double>
         </property>
        </widget>
       </item>
       <item row="2" column="2">
        <widget class="QDoubleSpinBox" name="sbTransY">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>0</height>
          </size>
         </property>
         <property name="baseSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="styleSheet">
          <string notr="true">background-color:rgb(0, 0, 240)</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="suffix">
          <string> mm</string>
         </property>
         <property name="minimum">
          <double>-9999.000000000000000</double>
         </property>
         <property name="maximum">
          <double>9999.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.500000000000000</double>
         </property>
        </widget>
       </item>
       <item row="3" column="2">
        <widget class="QDoubleSpinBox" name="sbTransZ">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>0</height>
          </size>
         </property>
         <property name="baseSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="styleSheet">
          <string notr="true">background-color:rgb(255, 0, 0)</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="suffix">
          <string> mm</string>
         </property>
         <property name="minimum">
          <double>-9999.000000000000000</double>
         </property>
         <property name="maximum">
          <double>9999.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.500000000000000</double>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_2">
      <property name="title">
       <string>Rotation</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
       <property name="leftMargin">
        <number>6</number>
       </property>
       <property name="topMargin">
        <number>3</number>
       </property>
       <property name="rightMargin">
        <number>6</number>
       </property>
       <property name="bottomMargin">
        <number>3</number>
       </property>
       <property name="verticalSpacing">
        <number>6</number>
       </property>
       <item row="2" column="0">
        <widget class="QLabel" name="label_6">
         <property name="text">
          <string>y (Coronal)</string>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QLabel" name="label_7">
         <property name="text">
          <string>x (Sagittal)</string>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QLabel" name="label_8">
         <property name="text">
          <string>z (Axial)</string>
         </property>
        </widget>
       </item>
       <item row="3" column="1">
        <widget class="QSlider" name="slideRotZ">
         <property name="minimum">
          <number>-180</number>
         </property>
         <property name="maximum">
          <number>180</number>
         </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QSlider" name="slideRotY">
         <property name="minimum">
          <number>-180</number>
         </property>
         <property name="maximum">
          <number>180</number>
         </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QSlider" name="slideRotX">
         <property name="minimum">
          <number>-180</number>
         </property>
         <property name="maximum">
          <number>180</number>
         </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <widget class="QDoubleSpinBox" name="sbRotX">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>86</width>
           <height>0</height>
          </size>
         </property>
         <property name="baseSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="styleSheet">
          <string notr="true">background-color:rgb(0, 170, 0)</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="prefix">
          <string/>
         </property>
         <property name="suffix">
          <string> °</string>
         </property>
         <property name="minimum">
          <double>-360.000000000000000</double>
         </property>
         <property name="maximum">
          <double>360.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.500000000000000</double>
         </property>
        </widget>
       </item>
       <item row="2" column="2">
        <widget class="QDoubleSpinBox" name="sbRotY">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>86</width>
           <height>0</height>
          </size>
         </property>
         <property name="baseSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="styleSheet">
          <string notr="true">background-color:rgb(0, 0, 240)</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="suffix">
          <string> °</string>
         </property>
         <property name="minimum">
          <double>-360.000000000000000</double>
         </property>
         <property name="maximum">
          <double>360.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.500000000000000</double>
         </property>
        </widget>
       </item>
       <item row="3" column="2">
        <widget class="QDoubleSpinBox" name="sbRotZ">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>86</width>
           <height>0</height>
          </size>
         </property>
         <property name="baseSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="styleSheet">
          <string notr="true">background-color:rgb(255, 0, 0)</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="suffix">
          <string> °</string>
         </property>
         <property name="minimum">
          <double>-360.000000000000000</double>
         </property>
         <property name="maximum">
          <double>360.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.500000000000000</double>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupScale">
      <property name="title">
       <string>Scaling</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_4">
       <property name="leftMargin">
        <number>6</number>
       </property>
       <property name="topMargin">
        <number>3</number>
       </property>
       <property name="rightMargin">
        <number>6</number>
       </property>
       <property name="bottomMargin">
        <number>3</number>
       </property>
       <item row="2" column="0">
        <widget class="QLabel" name="label_9">
         <property name="text">
-         <string>y (Sagital)</string>
+         <string>y (Sagittal)</string>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QLabel" name="label_10">
         <property name="text">
          <string>x (Frontal)</string>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QLabel" name="label_11">
         <property name="text">
          <string>z (Axial)</string>
         </property>
        </widget>
       </item>
       <item row="3" column="1">
        <widget class="QSlider" name="slideScaleZ">
         <property name="minimum">
          <number>-100</number>
         </property>
         <property name="maximum">
          <number>100</number>
         </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QSlider" name="slideScaleY">
         <property name="minimum">
          <number>-100</number>
         </property>
         <property name="maximum">
          <number>100</number>
         </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QSlider" name="slideScaleX">
         <property name="minimum">
          <number>-100</number>
         </property>
         <property name="maximum">
          <number>100</number>
         </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <widget class="QDoubleSpinBox" name="sbScaleX">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>0</height>
          </size>
         </property>
         <property name="baseSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="minimum">
          <double>-9999.000000000000000</double>
         </property>
         <property name="maximum">
          <double>9999.000000000000000</double>
         </property>
        </widget>
       </item>
       <item row="2" column="2">
        <widget class="QDoubleSpinBox" name="sbScaleY">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>0</height>
          </size>
         </property>
         <property name="baseSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="minimum">
          <double>-9999.000000000000000</double>
         </property>
         <property name="maximum">
          <double>9999.000000000000000</double>
         </property>
        </widget>
       </item>
       <item row="3" column="2">
        <widget class="QDoubleSpinBox" name="sbScaleZ">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>0</height>
          </size>
         </property>
         <property name="baseSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="minimum">
          <double>-9999.000000000000000</double>
         </property>
         <property name="maximum">
          <double>9999.000000000000000</double>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
  <designerdata>
   <property name="gridDeltaX">
    <number>5</number>
   </property>
   <property name="gridDeltaY">
    <number>5</number>
   </property>
   <property name="gridSnapX">
    <bool>true</bool>
   </property>
   <property name="gridSnapY">
    <bool>true</bool>
   </property>
   <property name="gridVisible">
    <bool>true</bool>
   </property>
  </designerdata>
 </ui>
diff --git a/Modules/Multilabel/Testing/files.cmake b/Modules/Multilabel/Testing/files.cmake
index f9fd59ebd2..bf283fc5a7 100644
--- a/Modules/Multilabel/Testing/files.cmake
+++ b/Modules/Multilabel/Testing/files.cmake
@@ -1,8 +1,9 @@
 set(MODULE_TESTS
     mitkLabelTest.cpp
     mitkLabelSetTest.cpp
     mitkLabelSetImageTest.cpp
     mitkLabelSetImageIOTest.cpp
     mitkLabelSetImageSurfaceStampFilterTest.cpp
+    mitkTransferLabelTest.cpp
 )
 
diff --git a/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp b/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp
index 97516291b0..612295804f 100644
--- a/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp
+++ b/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp
@@ -1,442 +1,519 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkIOUtil.h>
 #include <mitkImageStatisticsHolder.h>
 #include <mitkLabelSetImage.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
+#include <mitkAutoCropImageFilter.h>
+
 class mitkLabelSetImageTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkLabelSetImageTestSuite);
   MITK_TEST(TestInitialize);
   MITK_TEST(TestAddLayer);
   MITK_TEST(TestGetActiveLabelSet);
   MITK_TEST(TestGetActiveLabel);
   MITK_TEST(TestInitializeByLabeledImage);
   MITK_TEST(TestGetLabelSet);
   MITK_TEST(TestGetLabel);
   MITK_TEST(TestSetExteriorLabel);
   MITK_TEST(TestGetTotalNumberOfLabels);
   MITK_TEST(TestExistsLabel);
   MITK_TEST(TestExistsLabelSet);
   MITK_TEST(TestSetActiveLayer);
   MITK_TEST(TestRemoveLayer);
   MITK_TEST(TestRemoveLabels);
-  MITK_TEST(TestMergeLabel);
+  MITK_TEST(TestEraseLabels);
+  MITK_TEST(TestMergeLabels);
+  MITK_TEST(TestCreateLabelMask);
   CPPUNIT_TEST_SUITE_END();
 
 private:
   mitk::LabelSetImage::Pointer m_LabelSetImage;
 
 public:
   void setUp() override
   {
     // Create a new labelset image
     m_LabelSetImage = mitk::LabelSetImage::New();
     mitk::Image::Pointer regularImage = mitk::Image::New();
     unsigned int dimensions[3] = { 96, 128, 52 };
     regularImage->Initialize(mitk::MakeScalarPixelType<char>(), 3, dimensions);
     m_LabelSetImage->Initialize(regularImage);
   }
 
   void tearDown() override
   {
     // Delete LabelSetImage
     m_LabelSetImage = nullptr;
   }
 
   void TestInitialize()
   {
     // LabelSet image should always has the pixel type mitk::Label::PixelType
     CPPUNIT_ASSERT_MESSAGE("LabelSetImage has wrong pixel type",
                            m_LabelSetImage->GetPixelType() == mitk::MakeScalarPixelType<mitk::Label::PixelType>());
 
     mitk::Image::Pointer regularImage = mitk::Image::New();
     unsigned int dimensions[3] = { 96, 128, 52 };
     regularImage->Initialize(mitk::MakeScalarPixelType<char>(), 3, dimensions);
 
     mitk::BaseGeometry::Pointer regularImageGeo = regularImage->GetGeometry();
     mitk::BaseGeometry::Pointer labelImageGeo = m_LabelSetImage->GetGeometry();
     MITK_ASSERT_EQUAL(labelImageGeo, regularImageGeo, "LabelSetImage has wrong geometry");
 
     // By default one layer containing the exterior label should be added
     CPPUNIT_ASSERT_MESSAGE("Image was not correctly initialized - number of layers is not one",
                            m_LabelSetImage->GetNumberOfLayers() == 1);
     CPPUNIT_ASSERT_MESSAGE("Image was not correctly initialized - active layer has wrong ID",
                            m_LabelSetImage->GetActiveLayer() == 0);
 
     CPPUNIT_ASSERT_MESSAGE("Image was not correctly initialized - active label is not the exterior label",
                            m_LabelSetImage->GetActiveLabel()->GetValue() == 0);
   }
 
   void TestAddLayer()
   {
     CPPUNIT_ASSERT_MESSAGE("Number of layers is not zero", m_LabelSetImage->GetNumberOfLayers() == 1);
 
     m_LabelSetImage->AddLayer();
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - number of layers is not one",
                            m_LabelSetImage->GetNumberOfLayers() == 2);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active layer has wrong ID",
                            m_LabelSetImage->GetActiveLayer() == 1);
 
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is not the exterior label",
                            m_LabelSetImage->GetActiveLabel()->GetValue() == 0);
 
     mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     label1->SetValue(1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     label2->SetValue(200);
 
     newlayer->AddLabel(label1);
     newlayer->AddLabel(label2);
     newlayer->SetActiveLabel(200);
 
     unsigned int layerID = m_LabelSetImage->AddLayer(newlayer);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - number of layers is not two",
                            m_LabelSetImage->GetNumberOfLayers() == 3);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active layer has wrong ID",
                            m_LabelSetImage->GetActiveLayer() == layerID);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is wrong",
                            m_LabelSetImage->GetActiveLabel(layerID)->GetValue() == 200);
   }
 
   void TestGetActiveLabelSet()
   {
     mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     label1->SetValue(1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     label2->SetValue(200);
 
     newlayer->AddLabel(label1);
     newlayer->AddLabel(label2);
     newlayer->SetActiveLabel(200);
 
     unsigned int layerID = m_LabelSetImage->AddLayer(newlayer);
 
     mitk::LabelSet::Pointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
 
     CPPUNIT_ASSERT_MESSAGE("Wrong layer ID was returned", layerID == 1);
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned", mitk::Equal(*newlayer, *activeLayer, 0.00001, true));
 
     mitk::LabelSet::ConstPointer constActiveLayer = const_cast<const mitk::LabelSetImage*>(m_LabelSetImage.GetPointer())->GetActiveLabelSet();
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned", mitk::Equal(*newlayer, *constActiveLayer, 0.00001, true));
   }
 
   void TestGetActiveLabel()
   {
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     mitk::Label::PixelType value1 = 1;
     label1->SetValue(value1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     mitk::Label::PixelType value2 = 200;
     label2->SetValue(value2);
 
     m_LabelSetImage->GetActiveLabelSet()->AddLabel(label1);
     m_LabelSetImage->GetActiveLabelSet()->AddLabel(label2);
     m_LabelSetImage->GetActiveLabelSet()->SetActiveLabel(1);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is wrong",
                            m_LabelSetImage->GetActiveLabel()->GetValue() == value1);
     m_LabelSetImage->GetActiveLabelSet()->SetActiveLabel(value2);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is wrong",
                            m_LabelSetImage->GetActiveLabel()->GetValue() == value2);
 
     CPPUNIT_ASSERT_MESSAGE("Active Label was not correctly retreived with const getter",
       const_cast<const mitk::LabelSetImage*>(m_LabelSetImage.GetPointer())->GetActiveLabel()->GetValue() == value2);
 
   }
 
   void TestInitializeByLabeledImage()
   {
     mitk::Image::Pointer image =
       mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
     m_LabelSetImage->InitializeByLabeledImage(image);
     CPPUNIT_ASSERT_MESSAGE("Image - number of labels is not 6", m_LabelSetImage->GetNumberOfLabels() == 6);
   }
 
   void TestGetLabelSet()
   {
     // Test get non existing lset
     mitk::LabelSet::ConstPointer lset = m_LabelSetImage->GetLabelSet(10000);
     CPPUNIT_ASSERT_MESSAGE("Non existing labelset is not nullptr", lset.IsNull());
 
     lset = m_LabelSetImage->GetLabelSet(0);
     CPPUNIT_ASSERT_MESSAGE("Existing labelset is nullptr", lset.IsNotNull());
   }
 
   void TestGetLabel()
   {
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     mitk::Label::PixelType value1 = 1;
     label1->SetValue(value1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     mitk::Label::PixelType value2 = 200;
     label2->SetValue(value2);
 
     m_LabelSetImage->GetActiveLabelSet()->AddLabel(label1);
     m_LabelSetImage->AddLayer();
     m_LabelSetImage->GetLabelSet(1)->AddLabel(label2);
 
     CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for active layer",
                            mitk::Equal(*m_LabelSetImage->GetLabel(1), *label1, 0.0001, true));
     CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for layer 1",
                            mitk::Equal(*m_LabelSetImage->GetLabel(200, 1), *label2, 0.0001, true));
 
     // Try to get a non existing label
     mitk::Label *label3 = m_LabelSetImage->GetLabel(1000);
     CPPUNIT_ASSERT_MESSAGE("Non existing label should be nullptr", label3 == nullptr);
 
     // Try to get a label from a non existing layer
     label3 = m_LabelSetImage->GetLabel(200, 1000);
     CPPUNIT_ASSERT_MESSAGE("Label from non existing layer should be nullptr", label3 == nullptr);
   }
 
   void TestSetExteriorLabel()
   {
     mitk::Label::Pointer exteriorLabel = mitk::Label::New();
     exteriorLabel->SetName("MyExteriorSpecialLabel");
     mitk::Label::PixelType value1 = 10000;
     exteriorLabel->SetValue(value1);
 
     m_LabelSetImage->SetExteriorLabel(exteriorLabel);
     CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for layer 1",
                            mitk::Equal(*m_LabelSetImage->GetExteriorLabel(), *exteriorLabel, 0.0001, true));
 
     // Exterior label should be set automatically for each new layer
     m_LabelSetImage->AddLayer();
     CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for layer 1",
                            mitk::Equal(*m_LabelSetImage->GetLabel(10000, 1), *exteriorLabel, 0.0001, true));
   }
 
   void TestGetTotalNumberOfLabels()
   {
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     mitk::Label::PixelType value1 = 1;
     label1->SetValue(value1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     mitk::Label::PixelType value2 = 200;
     label2->SetValue(value2);
 
     m_LabelSetImage->GetActiveLabelSet()->AddLabel(label1);
     m_LabelSetImage->AddLayer();
     m_LabelSetImage->GetLabelSet(1)->AddLabel(label2);
     CPPUNIT_ASSERT_MESSAGE(
       "Wrong total number of labels",
       m_LabelSetImage->GetTotalNumberOfLabels() == 4); // added 2 labels + 2 exterior default labels
   }
 
   void TestExistsLabel()
   {
     mitk::Label::Pointer label = mitk::Label::New();
     label->SetName("Label2");
     mitk::Label::PixelType value = 200;
     label->SetValue(value);
 
     m_LabelSetImage->AddLayer();
     m_LabelSetImage->GetLabelSet(1)->AddLabel(label);
     m_LabelSetImage->SetActiveLayer(0);
     CPPUNIT_ASSERT_MESSAGE("Existing label was not found", m_LabelSetImage->ExistLabel(value) == true);
 
     CPPUNIT_ASSERT_MESSAGE("Non existing label was found", m_LabelSetImage->ExistLabel(10000) == false);
   }
 
   void TestExistsLabelSet()
   {
     // Cache active layer
     mitk::LabelSet::ConstPointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
 
     // Add new layer
     mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     label1->SetValue(1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     label2->SetValue(200);
 
     newlayer->AddLabel(label1);
     newlayer->AddLabel(label2);
     newlayer->SetActiveLabel(200);
 
     m_LabelSetImage->AddLayer(newlayer);
 
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == true);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(1) == true);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(20) == false);
   }
 
   void TestSetActiveLayer()
   {
     // Cache active layer
     mitk::LabelSet::ConstPointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
 
     // Add new layer
     mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     label1->SetValue(1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     label2->SetValue(200);
 
     newlayer->AddLabel(label1);
     newlayer->AddLabel(label2);
     newlayer->SetActiveLabel(200);
 
     unsigned int layerID = m_LabelSetImage->AddLayer(newlayer);
 
     // Set initial layer as active layer
     m_LabelSetImage->SetActiveLayer(0);
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
                            mitk::Equal(*activeLayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
 
     // Set previously added layer as active layer
     m_LabelSetImage->SetActiveLayer(layerID);
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
                            mitk::Equal(*newlayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
 
     // Set a non existing layer as active layer - nothing should change
     m_LabelSetImage->SetActiveLayer(10000);
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
                            mitk::Equal(*newlayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
   }
 
   void TestRemoveLayer()
   {
     // Cache active layer
     mitk::LabelSet::ConstPointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
 
     // Add new layers
     m_LabelSetImage->AddLayer();
 
     mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     label1->SetValue(1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     label2->SetValue(200);
 
     newlayer->AddLabel(label1);
     newlayer->AddLabel(label2);
     newlayer->SetActiveLabel(200);
 
     m_LabelSetImage->AddLayer(newlayer);
 
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
                            mitk::Equal(*newlayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
 
     m_LabelSetImage->RemoveLayer();
     CPPUNIT_ASSERT_MESSAGE("Wrong number of layers, after a layer was removed",
                            m_LabelSetImage->GetNumberOfLayers() == 2);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(2) == false);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(1) == true);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == true);
 
     m_LabelSetImage->RemoveLayer();
     CPPUNIT_ASSERT_MESSAGE("Wrong number of layers, after a layer was removed",
                            m_LabelSetImage->GetNumberOfLayers() == 1);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(1) == false);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == true);
     CPPUNIT_ASSERT_MESSAGE("Wrong active layer",
                            mitk::Equal(*activeLayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
 
     m_LabelSetImage->RemoveLayer();
     CPPUNIT_ASSERT_MESSAGE("Wrong number of layers, after a layer was removed",
                            m_LabelSetImage->GetNumberOfLayers() == 0);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == false);
     CPPUNIT_ASSERT_MESSAGE("Active layers is not nullptr although all layer have been removed",
                            m_LabelSetImage->GetActiveLabelSet() == nullptr);
   }
 
   void TestRemoveLabels()
   {
     mitk::Image::Pointer image =
       mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
+
+    m_LabelSetImage = nullptr;
+    m_LabelSetImage = mitk::LabelSetImage::New();
     m_LabelSetImage->InitializeByLabeledImage(image);
 
     CPPUNIT_ASSERT_MESSAGE("Image - number of labels is not 6", m_LabelSetImage->GetNumberOfLabels() == 6);
     // 2ndMin because of the exterior label = 0
-    CPPUNIT_ASSERT_MESSAGE("Labels with value 1 and 3 was not remove from the image",
-                           m_LabelSetImage->GetStatistics()->GetScalarValue2ndMin() == 1);
-    CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image",
-                           m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 7);
+    CPPUNIT_ASSERT_MESSAGE("Wrong MIN value", m_LabelSetImage->GetStatistics()->GetScalarValue2ndMin() == 1);
+    CPPUNIT_ASSERT_MESSAGE("Wrong MAX value", m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 7);
 
-    CPPUNIT_ASSERT_MESSAGE("Label with ID 3 does not exists after initialization",
+    CPPUNIT_ASSERT_MESSAGE("Label with ID 3 does not exist after initialization",
                            m_LabelSetImage->ExistLabel(3) == true);
-    CPPUNIT_ASSERT_MESSAGE("Label with ID 7 does not exists after initialization",
-                           m_LabelSetImage->ExistLabel(7) == true);
 
+    m_LabelSetImage->RemoveLabel(1);
     std::vector<mitk::Label::PixelType> labelsToBeRemoved;
-    labelsToBeRemoved.push_back(1);
     labelsToBeRemoved.push_back(3);
     labelsToBeRemoved.push_back(7);
     m_LabelSetImage->RemoveLabels(labelsToBeRemoved);
 
     CPPUNIT_ASSERT_MESSAGE("Wrong number of labels after some have been removed",
                            m_LabelSetImage->GetNumberOfLabels() == 3);
-    // Values within the image are 0, 1, 3, 5, 6, 7 - New Min/Max value should be 5 / 6
+    // Values within the image are 0, 1, 3, 5, 6, 7 - New Min / Max value should be 5 / 6
     // 2ndMin because of the exterior label = 0
-    CPPUNIT_ASSERT_MESSAGE("Labels with value 1 and 3 was not remove from the image",
+    CPPUNIT_ASSERT_MESSAGE("Labels with value 1 and 3 were not removed from the image",
                            m_LabelSetImage->GetStatistics()->GetScalarValue2ndMin() == 5);
-    CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image",
+    CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not removed from the image",
                            m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 6);
   }
 
-  void TestMergeLabel()
+  void TestEraseLabels()
   {
-    mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
+    mitk::Image::Pointer image =
+      mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
+
     m_LabelSetImage = nullptr;
     m_LabelSetImage = mitk::LabelSetImage::New();
     m_LabelSetImage->InitializeByLabeledImage(image);
 
     CPPUNIT_ASSERT_MESSAGE("Image - number of labels is not 6", m_LabelSetImage->GetNumberOfLabels() == 6);
+    // 2ndMin because of the exterior label = 0
+    CPPUNIT_ASSERT_MESSAGE("Wrong MIN value", m_LabelSetImage->GetStatistics()->GetScalarValue2ndMin() == 1);
+    CPPUNIT_ASSERT_MESSAGE("Wrong MAX value", m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 7);
+
+    CPPUNIT_ASSERT_MESSAGE("Label with ID 3 does not exist after initialization",
+      m_LabelSetImage->ExistLabel(3) == true);
+
+    m_LabelSetImage->EraseLabel(1);
+    std::vector<mitk::Label::PixelType> labelsToBeErased;
+    labelsToBeErased.push_back(3);
+    labelsToBeErased.push_back(7);
+    m_LabelSetImage->EraseLabels(labelsToBeErased);
+
+    CPPUNIT_ASSERT_MESSAGE("Wrong number of labels since none have been removed",
+      m_LabelSetImage->GetNumberOfLabels() == 6);
+    // Values within the image are 0, 1, 3, 5, 6, 7 - New Min / Max value should be 5 / 6
+    // 2ndMin because of the exterior label = 0
+    CPPUNIT_ASSERT_MESSAGE("Labels with value 1 and 3 were not erased from the image",
+      m_LabelSetImage->GetStatistics()->GetScalarValue2ndMin() == 5);
+    CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not erased from the image",
+      m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 6);
+  }
+
+  void TestMergeLabels()
+  {
+    mitk::Image::Pointer image =
+      mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
 
+    m_LabelSetImage = nullptr;
+    m_LabelSetImage = mitk::LabelSetImage::New();
+    m_LabelSetImage->InitializeByLabeledImage(image);
+
+    CPPUNIT_ASSERT_MESSAGE("Image - number of labels is not 6", m_LabelSetImage->GetNumberOfLabels() == 6);
     // 2ndMin because of the exterior label = 0
-    CPPUNIT_ASSERT_MESSAGE("Wrong MIN value", m_LabelSetImage->GetStatistics()->GetScalarValueMin() == 0);
+    CPPUNIT_ASSERT_MESSAGE("Wrong MIN value", m_LabelSetImage->GetStatistics()->GetScalarValue2ndMin() == 1);
     CPPUNIT_ASSERT_MESSAGE("Wrong MAX value", m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 7);
 
-    m_LabelSetImage->GetActiveLabelSet()->SetActiveLabel(6);
-    // Merge label 7 with label 0. Result should be that label 7 is not present any more
+    CPPUNIT_ASSERT_MESSAGE("Label with ID 6 does not exist after initialization",
+      m_LabelSetImage->ExistLabel(6) == true);
+
+    // Merge label 7 with label 6. Result should be that label 7 is not present anymore.
     m_LabelSetImage->MergeLabel(6, 7);
-    CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image", m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 6);
-    m_LabelSetImage->GetStatistics()->GetScalarValue2ndMax();
+    CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not removed from the image", m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 6);
 
+    // Count all pixels with value 6 = 507
     // Count all pixels with value 7 = 823
+    // Check if merged label has 507 + 823 = 1330 pixels
+    CPPUNIT_ASSERT_MESSAGE("Labels were not correctly merged", m_LabelSetImage->GetStatistics()->GetCountOfMaxValuedVoxels() == 1330);
+
+    CPPUNIT_ASSERT_MESSAGE("Label with ID 3 does not exist after initialization",
+      m_LabelSetImage->ExistLabel(3) == true);
+    CPPUNIT_ASSERT_MESSAGE("Label with ID 5 does not exist after initialization",
+      m_LabelSetImage->ExistLabel(5) == true);
+
+    // Merge labels 5 and 6 with 3. Result should be that labels 5 and 6 are not present anymore.
+    std::vector<mitk::Label::PixelType> vectorOfSourcePixelValues{ 5, 6 };
+    m_LabelSetImage->MergeLabels(3, vectorOfSourcePixelValues);
+    // Values within the image are 0, 1, 3, 5, 6, 7 - New Max value should be 3
+    CPPUNIT_ASSERT_MESSAGE("Labels with value 5 and 6 were not removed from the image", m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 3);
+
+    // Count all pixels with value 3 = 1893
+    // Count all pixels with value 5 = 2143
+    // Count all pixels with value 6 = 1330
+    // Check if merged label has 1893 + 2143 + 1330 = 5366 pixels
+    CPPUNIT_ASSERT_MESSAGE("Labels were not correctly merged", m_LabelSetImage->GetStatistics()->GetCountOfMaxValuedVoxels() == 5366);
+  }
+
+  void TestCreateLabelMask()
+  {
+    mitk::Image::Pointer image =
+      mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
+
+    m_LabelSetImage = nullptr;
+    m_LabelSetImage = mitk::LabelSetImage::New();
+    m_LabelSetImage->InitializeByLabeledImage(image);
+
+    auto labelMask = m_LabelSetImage->CreateLabelMask(6);
+
+    mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
+    cropFilter->SetInput(labelMask);
+    cropFilter->SetBackgroundValue(0);
+    cropFilter->SetMarginFactor(1.15);
+    cropFilter->Update();
+    auto maskImage = cropFilter->GetOutput();
+
     // Count all pixels with value 6 = 507
-    // Check if merge label has 507 + 823 = 1330 pixels
-    CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image", m_LabelSetImage->GetStatistics()->GetCountOfMaxValuedVoxels() == 1330);
+    CPPUNIT_ASSERT_MESSAGE("Label mask not correctly created", maskImage->GetStatistics()->GetCountOfMaxValuedVoxels() == 507);
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkLabelSetImage)
diff --git a/Modules/Multilabel/Testing/mitkLabelSetTest.cpp b/Modules/Multilabel/Testing/mitkLabelSetTest.cpp
index d4c71fc23e..8db2f35179 100644
--- a/Modules/Multilabel/Testing/mitkLabelSetTest.cpp
+++ b/Modules/Multilabel/Testing/mitkLabelSetTest.cpp
@@ -1,170 +1,170 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkLabelSet.h>
 #include <mitkLabelSetImage.h>
 #include <mitkStringProperty.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 class mitkLabelSetTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkLabelSetTestSuite);
   MITK_TEST(TestSetLayer);
   MITK_TEST(TestSetActiveLabel);
   MITK_TEST(TestRemoveLabel);
   MITK_TEST(TestAddLabel);
   MITK_TEST(TestRenameLabel);
   MITK_TEST(TestSetAllLabelsVisible);
   MITK_TEST(TestSetAllLabelsLocked);
   MITK_TEST(TestRemoveAllLabels);
   CPPUNIT_TEST_SUITE_END();
 
 private:
   mitk::LabelSet::Pointer m_LabelSet;
   mitk::LabelSet::PixelType m_InitialNumberOfLabels;
 
   void AddLabels(mitk::LabelSet::PixelType numOfLabels)
   {
     mitk::Label::Pointer label;
     const std::string namePrefix = "Label_";
     const mitk::Color gray(0.5f);
 
     for (mitk::Label::PixelType i = 0; i < numOfLabels; ++i)
     {
       label = mitk::Label::New();
       label->SetName(namePrefix + std::to_string(i));
       label->SetValue(i);
       label->SetVisible((i % 2 == 0));
       label->SetLayer(i % 3);
       label->SetColor(gray);
 
       m_LabelSet->AddLabel(label);
     }
   }
 
 public:
   void setUp() override
   {
     m_InitialNumberOfLabels = 6;
     m_LabelSet = mitk::LabelSet::New();
 
     this->AddLabels(m_InitialNumberOfLabels);
     m_LabelSet->SetLayer(0);
     m_LabelSet->SetActiveLabel(0);
   }
 
   void tearDown() override
   {
     m_LabelSet = nullptr;
   }
 
   void TestSetLayer()
   {
     CPPUNIT_ASSERT_MESSAGE("Wrong initial layer", m_LabelSet->GetLayer() == 0);
 
     m_LabelSet->SetLayer(1);
     CPPUNIT_ASSERT_MESSAGE("Wrong layer", m_LabelSet->GetLayer() == 1);
   }
 
   void TestSetActiveLabel()
   {
     CPPUNIT_ASSERT_MESSAGE("Wrong initial active label", m_LabelSet->GetActiveLabel()->GetValue() == 0);
 
     m_LabelSet->SetActiveLabel(1);
-    CPPUNIT_ASSERT_MESSAGE("Wrong layer", m_LabelSet->GetActiveLabel()->GetValue() == 1);
+    CPPUNIT_ASSERT_MESSAGE("Wrong active label", m_LabelSet->GetActiveLabel()->GetValue() == 1);
   }
 
   void TestRemoveLabel()
   {
     CPPUNIT_ASSERT_MESSAGE("Wrong initial number of label", m_LabelSet->GetNumberOfLabels() == m_InitialNumberOfLabels);
 
     // Remove a label that is not the active label
     m_LabelSet->SetActiveLabel(2);
     m_LabelSet->RemoveLabel(1);
 
     mitk::LabelSet::PixelType numLabels = m_InitialNumberOfLabels - 1;
 
     CPPUNIT_ASSERT_MESSAGE("Label was not removed", m_LabelSet->ExistLabel(1) == false);
     CPPUNIT_ASSERT_MESSAGE("Wrong number of label", m_LabelSet->GetNumberOfLabels() == numLabels);
     CPPUNIT_ASSERT_MESSAGE("Wrong active label", m_LabelSet->GetActiveLabel()->GetValue() == 2);
 
     // Remove active label - now the succeeding label should be active
     m_LabelSet->RemoveLabel(2);
-    CPPUNIT_ASSERT_MESSAGE("Wrong layer", m_LabelSet->GetActiveLabel()->GetValue() == 3);
+    CPPUNIT_ASSERT_MESSAGE("Wrong active label", m_LabelSet->GetActiveLabel()->GetValue() == 3);
     CPPUNIT_ASSERT_MESSAGE("Label was not removed", m_LabelSet->ExistLabel(2) == false);
     CPPUNIT_ASSERT_MESSAGE("Wrong initial number of label", m_LabelSet->GetNumberOfLabels() == --numLabels);
   }
 
   void TestAddLabel()
   {
     auto newLabel = mitk::Label::New();
     newLabel->SetValue(1);
     m_LabelSet->AddLabel(newLabel);
 
     // Since label with value 1 already exists the new label will get the value m_InitialNumberOfValues
     CPPUNIT_ASSERT_MESSAGE("Wrong label value", m_LabelSet->GetActiveLabel()->GetValue() == m_InitialNumberOfLabels);
     CPPUNIT_ASSERT_MESSAGE("Wrong number of label", m_LabelSet->GetNumberOfLabels() == static_cast<decltype(m_LabelSet->GetNumberOfLabels())>(m_InitialNumberOfLabels + 1));
   }
 
   void TestRenameLabel()
   {
     const mitk::Color white(1.0f);
     const std::string name = "MyAwesomeLabel";
 
     m_LabelSet->RenameLabel(0, name, white);
 
     const auto* label = m_LabelSet->GetLabel(0);
     CPPUNIT_ASSERT_MESSAGE("Wrong label name", label->GetName() == name );
 
     const auto& color = label->GetColor();
     CPPUNIT_ASSERT_MESSAGE("Wrong color", color == white);
   }
 
   void TestSetAllLabelsVisible()
   {
     const auto numLabels = static_cast<mitk::LabelSet::PixelType>(m_LabelSet->GetNumberOfLabels());
 
     m_LabelSet->SetAllLabelsVisible(true);
 
     for (mitk::LabelSet::PixelType i = 0; i < numLabels; ++i)
       CPPUNIT_ASSERT_MESSAGE("Label not visible", m_LabelSet->GetLabel(i)->GetVisible() == true);
 
     m_LabelSet->SetAllLabelsVisible(false);
 
     for (mitk::LabelSet::PixelType i = 0; i < numLabels; ++i)
       CPPUNIT_ASSERT_MESSAGE("Label visible", m_LabelSet->GetLabel(i)->GetVisible() == false);
   }
 
   void TestSetAllLabelsLocked()
   {
     const auto numLabels = static_cast<mitk::LabelSet::PixelType>(m_LabelSet->GetNumberOfLabels());
 
     m_LabelSet->SetAllLabelsLocked(true);
 
     for (mitk::LabelSet::PixelType i = 0; i < numLabels; ++i)
       CPPUNIT_ASSERT_MESSAGE("Label not locked", m_LabelSet->GetLabel(i)->GetLocked() == true);
 
     m_LabelSet->SetAllLabelsLocked(false);
 
     for (mitk::LabelSet::PixelType i = 0; i < numLabels; ++i)
       CPPUNIT_ASSERT_MESSAGE("Label locked", m_LabelSet->GetLabel(i)->GetLocked() == false);
   }
 
   void TestRemoveAllLabels()
   {
     m_LabelSet->RemoveAllLabels();
     CPPUNIT_ASSERT_MESSAGE("Not all labels were removed", m_LabelSet->GetNumberOfLabels() == 0);
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkLabelSet)
diff --git a/Modules/Multilabel/Testing/mitkTransferLabelTest.cpp b/Modules/Multilabel/Testing/mitkTransferLabelTest.cpp
new file mode 100644
index 0000000000..6df3b1d69a
--- /dev/null
+++ b/Modules/Multilabel/Testing/mitkTransferLabelTest.cpp
@@ -0,0 +1,142 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include <mitkIOUtil.h>
+#include <mitkLabelSetImage.h>
+#include <mitkTestFixture.h>
+#include <mitkTestingMacros.h>
+
+class mitkTransferLabelTestSuite : public mitk::TestFixture
+{
+  CPPUNIT_TEST_SUITE(mitkTransferLabelTestSuite);
+  MITK_TEST(TestTransfer_defaults);
+  MITK_TEST(TestTransfer_Merge_RegardLocks);
+  MITK_TEST(TestTransfer_Merge_IgnoreLocks);
+  MITK_TEST(TestTransfer_Replace_RegardLocks);
+  MITK_TEST(TestTransfer_Replace_IgnoreLocks);
+  MITK_TEST(TestTransfer_multipleLabels);
+  CPPUNIT_TEST_SUITE_END();
+
+private:
+  mitk::LabelSetImage::Pointer m_SourceImage;
+
+public:
+  void setUp() override
+  {
+    m_SourceImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_source.nrrd"));
+  }
+
+  void tearDown() override
+  {
+    m_SourceImage = nullptr;
+  }
+
+  void TestTransfer_defaults()
+  {
+    auto destinationImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination.nrrd"));
+    auto destinationLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination_lockedExterior.nrrd"));
+    auto refmage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_replace_regardLocks.nrrd"));
+    auto refLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_replace_regardLocks_lockedExterior.nrrd"));
+
+    mitk::TransferLabelContent(m_SourceImage, destinationImage);
+    mitk::TransferLabelContent(m_SourceImage, destinationLockedExteriorImage);
+
+    CPPUNIT_ASSERT_MESSAGE("Transfer with default settings failed",
+      mitk::Equal(*(destinationImage.GetPointer()), *(refmage.GetPointer()), mitk::eps, false));
+    CPPUNIT_ASSERT_MESSAGE("Transfer with default settings + exterior lock failed",
+      mitk::Equal(*(destinationLockedExteriorImage.GetPointer()), *(refLockedExteriorImage.GetPointer()), mitk::eps, false));
+  }
+
+  void TestTransfer_Merge_RegardLocks()
+  {
+    auto destinationImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination.nrrd"));
+    auto destinationLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination_lockedExterior.nrrd"));
+    auto refmage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_merge_regardLocks.nrrd"));
+    auto refLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_merge_regardLocks_lockedExterior.nrrd"));
+
+    mitk::TransferLabelContent(m_SourceImage, destinationImage, { {1,1} }, mitk::MultiLabelSegmentation::MergeStyle::Merge, mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks);
+    mitk::TransferLabelContent(m_SourceImage, destinationLockedExteriorImage, { {1,1} }, mitk::MultiLabelSegmentation::MergeStyle::Merge, mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks);
+
+    CPPUNIT_ASSERT_MESSAGE("Transfer with merge + regardLocks settings failed",
+      mitk::Equal(*(destinationImage.GetPointer()), *(refmage.GetPointer()), mitk::eps, false));
+    CPPUNIT_ASSERT_MESSAGE("Transfer with merge + regardLocks + exterior lock settings failed",
+      mitk::Equal(*(destinationLockedExteriorImage.GetPointer()), *(refLockedExteriorImage.GetPointer()), mitk::eps, false));
+  }
+
+  void TestTransfer_Merge_IgnoreLocks()
+  {
+    auto destinationImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination.nrrd"));
+    auto destinationLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination_lockedExterior.nrrd"));
+    auto refmage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_merge_ignoreLocks.nrrd"));
+    auto refLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_merge_ignoreLocks_lockedExterior.nrrd"));
+
+    mitk::TransferLabelContent(m_SourceImage, destinationImage, { {1,1} }, mitk::MultiLabelSegmentation::MergeStyle::Merge, mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
+    mitk::TransferLabelContent(m_SourceImage, destinationLockedExteriorImage, { {1,1} }, mitk::MultiLabelSegmentation::MergeStyle::Merge, mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
+
+    CPPUNIT_ASSERT_MESSAGE("Transfer with merge + ignoreLocks settings failed",
+      mitk::Equal(*(destinationImage.GetPointer()), *(refmage.GetPointer()), mitk::eps, false));
+    CPPUNIT_ASSERT_MESSAGE("Transfer with merge + ignoreLocks + exterior lock settings failed",
+      mitk::Equal(*(destinationLockedExteriorImage.GetPointer()), *(refLockedExteriorImage.GetPointer()), mitk::eps, false));
+  }
+
+  void TestTransfer_Replace_RegardLocks()
+  {
+    auto destinationImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination.nrrd"));
+    auto destinationLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination_lockedExterior.nrrd"));
+    auto refmage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_replace_regardLocks.nrrd"));
+    auto refLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_replace_regardLocks_lockedExterior.nrrd"));
+
+    mitk::TransferLabelContent(m_SourceImage, destinationImage, { {1,1} }, mitk::MultiLabelSegmentation::MergeStyle::Replace, mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks);
+    mitk::TransferLabelContent(m_SourceImage, destinationLockedExteriorImage, { {1,1} }, mitk::MultiLabelSegmentation::MergeStyle::Replace, mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks);
+
+    CPPUNIT_ASSERT_MESSAGE("Transfer with replace + regardLocks settings failed",
+      mitk::Equal(*(destinationImage.GetPointer()), *(refmage.GetPointer()), mitk::eps, false));
+    CPPUNIT_ASSERT_MESSAGE("Transfer with replace + regardLocks + exterior lock settings failed",
+      mitk::Equal(*(destinationLockedExteriorImage.GetPointer()), *(refLockedExteriorImage.GetPointer()), mitk::eps, false));
+  }
+
+  void TestTransfer_Replace_IgnoreLocks()
+  {
+    auto destinationImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination.nrrd"));
+    auto destinationLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination_lockedExterior.nrrd"));
+    auto refmage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_replace_ignoreLocks.nrrd"));
+    auto refLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_replace_ignoreLocks_lockedExterior.nrrd"));
+
+    mitk::TransferLabelContent(m_SourceImage, destinationImage, { {1,1} }, mitk::MultiLabelSegmentation::MergeStyle::Replace, mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
+    mitk::TransferLabelContent(m_SourceImage, destinationLockedExteriorImage, { {1,1} }, mitk::MultiLabelSegmentation::MergeStyle::Replace, mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
+
+    CPPUNIT_ASSERT_MESSAGE("Transfer with replace + ignoreLocks settings failed",
+      mitk::Equal(*(destinationImage.GetPointer()), *(refmage.GetPointer()), mitk::eps, false));
+    CPPUNIT_ASSERT_MESSAGE("Transfer with replace + ignoreLocks + exterior lock settings failed",
+      mitk::Equal(*(destinationLockedExteriorImage.GetPointer()), *(refLockedExteriorImage.GetPointer()), mitk::eps, false));
+  }
+
+
+  void TestTransfer_multipleLabels()
+  {
+    auto destinationImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination.nrrd"));
+    auto destinationLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_destination_lockedExterior.nrrd"));
+    auto refmage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_multipleLabels.nrrd"));
+    auto refLockedExteriorImage = mitk::IOUtil::Load<mitk::LabelSetImage>(GetTestDataFilePath("Multilabel/LabelTransferTest_result_multipleLabels_lockedExterior.nrrd"));
+
+    mitk::TransferLabelContent(m_SourceImage, destinationImage, { {1,1}, {3,1}, {2,4}, {4,2} }, mitk::MultiLabelSegmentation::MergeStyle::Replace, mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
+    mitk::TransferLabelContent(m_SourceImage, destinationLockedExteriorImage, { {1,1}, {3,1}, {2,4}, {4,2} }, mitk::MultiLabelSegmentation::MergeStyle::Replace, mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
+
+    CPPUNIT_ASSERT_MESSAGE("Transfer multiple labels (1->1, 3->1, 2->4, 4->2) with replace + ignoreLocks settings failed",
+      mitk::Equal(*(destinationImage.GetPointer()), *(refmage.GetPointer()), mitk::eps, false));
+    CPPUNIT_ASSERT_MESSAGE("Transfer multiple labels (1->1, 3->1, 2->4, 4->2) with replace + ignoreLocks + exterior lock settings failed",
+      mitk::Equal(*(destinationLockedExteriorImage.GetPointer()), *(refLockedExteriorImage.GetPointer()), mitk::eps, false));
+  }
+
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkTransferLabel)
diff --git a/Modules/Multilabel/mitkLabelSetImage.cpp b/Modules/Multilabel/mitkLabelSetImage.cpp
index 9b4253fc63..6612d48157 100644
--- a/Modules/Multilabel/mitkLabelSetImage.cpp
+++ b/Modules/Multilabel/mitkLabelSetImage.cpp
@@ -1,1026 +1,1160 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkLabelSetImage.h"
 
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkImagePixelReadAccessor.h"
 #include "mitkImagePixelWriteAccessor.h"
 #include "mitkInteractionConst.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkPadImageFilter.h"
 #include "mitkRenderingManager.h"
 #include "mitkDICOMSegmentationPropertyHelper.h"
 #include "mitkDICOMQIPropertyHelper.h"
 
 #include <vtkCell.h>
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 
 #include <itkImageRegionIterator.h>
 #include <itkQuadEdgeMesh.h>
 #include <itkTriangleMeshToBinaryImageFilter.h>
 //#include <itkRelabelComponentImageFilter.h>
 
 #include <itkCommand.h>
 
+#include <itkBinaryFunctorImageFilter.h>
+
+
 template <typename TPixel, unsigned int VDimensions>
 void SetToZero(itk::Image<TPixel, VDimensions> *source)
 {
   source->FillBuffer(0);
 }
 
 template <unsigned int VImageDimension = 3>
 void CreateLabelMaskProcessing(mitk::Image *layerImage, mitk::Image *mask, mitk::LabelSet::PixelType index)
 {
   mitk::ImagePixelReadAccessor<mitk::LabelSet::PixelType, VImageDimension> readAccessor(layerImage);
   mitk::ImagePixelWriteAccessor<mitk::LabelSet::PixelType, VImageDimension> writeAccessor(mask);
 
   std::size_t numberOfPixels = 1;
   for (int dim = 0; dim < static_cast<int>(VImageDimension); ++dim)
     numberOfPixels *= static_cast<std::size_t>(readAccessor.GetDimension(dim));
 
   auto src = readAccessor.GetData();
   auto dest = writeAccessor.GetData();
 
   for (std::size_t i = 0; i < numberOfPixels; ++i)
   {
     if (index == *(src + i))
       *(dest + i) = 1;
   }
 }
 
 mitk::LabelSetImage::LabelSetImage()
   : mitk::Image(), m_ActiveLayer(0), m_activeLayerInvalid(false), m_ExteriorLabel(nullptr)
 {
   // Iniitlaize Background Label
   mitk::Color color;
   color.Set(0, 0, 0);
   m_ExteriorLabel = mitk::Label::New();
   m_ExteriorLabel->SetColor(color);
   m_ExteriorLabel->SetName("Exterior");
   m_ExteriorLabel->SetOpacity(0.0);
   m_ExteriorLabel->SetLocked(false);
   m_ExteriorLabel->SetValue(0);
 
   // Add some DICOM Tags as properties to segmentation image
   DICOMSegmentationPropertyHelper::DeriveDICOMSegmentationProperties(this);
 }
 
 mitk::LabelSetImage::LabelSetImage(const mitk::LabelSetImage &other)
   : Image(other),
     m_ActiveLayer(other.GetActiveLayer()),
     m_activeLayerInvalid(false),
     m_ExteriorLabel(other.GetExteriorLabel()->Clone())
 {
   for (unsigned int i = 0; i < other.GetNumberOfLayers(); i++)
   {
     // Clone LabelSet data
     mitk::LabelSet::Pointer lsClone = other.GetLabelSet(i)->Clone();
     // add modified event listener to LabelSet (listen to LabelSet changes)
     itk::SimpleMemberCommand<Self>::Pointer command = itk::SimpleMemberCommand<Self>::New();
     command->SetCallbackFunction(this, &mitk::LabelSetImage::OnLabelSetModified);
     lsClone->AddObserver(itk::ModifiedEvent(), command);
     m_LabelSetContainer.push_back(lsClone);
 
     // clone layer Image data
     mitk::Image::Pointer liClone = other.GetLayerImage(i)->Clone();
     m_LayerContainer.push_back(liClone);
   }
 
   // Add some DICOM Tags as properties to segmentation image
   DICOMSegmentationPropertyHelper::DeriveDICOMSegmentationProperties(this);
 }
 
 void mitk::LabelSetImage::OnLabelSetModified()
 {
   Superclass::Modified();
 }
 
 void mitk::LabelSetImage::SetExteriorLabel(mitk::Label *label)
 {
   m_ExteriorLabel = label;
 }
 
 mitk::Label *mitk::LabelSetImage::GetExteriorLabel()
 {
   return m_ExteriorLabel;
 }
 
 const mitk::Label *mitk::LabelSetImage::GetExteriorLabel() const
 {
   return m_ExteriorLabel;
 }
 
 void mitk::LabelSetImage::Initialize(const mitk::Image *other)
 {
   mitk::PixelType pixelType(mitk::MakeScalarPixelType<LabelSetImage::PixelType>());
   if (other->GetDimension() == 2)
   {
     const unsigned int dimensions[] = {other->GetDimension(0), other->GetDimension(1), 1};
     Superclass::Initialize(pixelType, 3, dimensions);
   }
   else
   {
     Superclass::Initialize(pixelType, other->GetDimension(), other->GetDimensions());
   }
 
   auto originalGeometry = other->GetTimeGeometry()->Clone();
   this->SetTimeGeometry(originalGeometry);
 
   // initialize image memory to zero
   if (4 == this->GetDimension())
   {
     AccessFixedDimensionByItk(this, SetToZero, 4);
   }
   else
   {
     AccessByItk(this, SetToZero);
   }
 
   // Transfer some general DICOM properties from the source image to derived image (e.g. Patient information,...)
   DICOMQIPropertyHelper::DeriveDICOMSourceProperties(other, this);
 
   // Add a inital LabelSet ans corresponding image data to the stack
-  AddLayer();
+  if (this->GetNumberOfLayers() == 0)
+  {
+    AddLayer();
+  }
 }
 
 mitk::LabelSetImage::~LabelSetImage()
 {
   m_LabelSetContainer.clear();
 }
 
 mitk::Image *mitk::LabelSetImage::GetLayerImage(unsigned int layer)
 {
   return m_LayerContainer[layer];
 }
 
 const mitk::Image *mitk::LabelSetImage::GetLayerImage(unsigned int layer) const
 {
   return m_LayerContainer[layer];
 }
 
 unsigned int mitk::LabelSetImage::GetActiveLayer() const
 {
   return m_ActiveLayer;
 }
 
 unsigned int mitk::LabelSetImage::GetNumberOfLayers() const
 {
   return m_LabelSetContainer.size();
 }
 
 void mitk::LabelSetImage::RemoveLayer()
 {
   int layerToDelete = GetActiveLayer();
   // remove all observers from active label set
   GetLabelSet(layerToDelete)->RemoveAllObservers();
 
   // set the active layer to one below, if exists.
   if (layerToDelete != 0)
   {
     SetActiveLayer(layerToDelete - 1);
   }
   else
   {
     // we are deleting layer zero, it should not be copied back into the vector
     m_activeLayerInvalid = true;
   }
 
   // remove labelset and image data
   m_LabelSetContainer.erase(m_LabelSetContainer.begin() + layerToDelete);
   m_LayerContainer.erase(m_LayerContainer.begin() + layerToDelete);
 
   if (layerToDelete == 0)
   {
     this->SetActiveLayer(layerToDelete);
   }
 
   this->Modified();
 }
 
-unsigned int mitk::LabelSetImage::AddLayer(mitk::LabelSet::Pointer lset)
+unsigned int mitk::LabelSetImage::AddLayer(mitk::LabelSet::Pointer labelSet)
 {
   mitk::Image::Pointer newImage = mitk::Image::New();
   newImage->Initialize(this->GetPixelType(),
                        this->GetDimension(),
                        this->GetDimensions(),
                        this->GetImageDescriptor()->GetNumberOfChannels());
   newImage->SetTimeGeometry(this->GetTimeGeometry()->Clone());
 
   if (newImage->GetDimension() < 4)
   {
     AccessByItk(newImage, SetToZero);
   }
   else
   {
     AccessFixedDimensionByItk(newImage, SetToZero, 4);
   }
 
-  unsigned int newLabelSetId = this->AddLayer(newImage, lset);
+  unsigned int newLabelSetId = this->AddLayer(newImage, labelSet);
 
   return newLabelSetId;
 }
 
-unsigned int mitk::LabelSetImage::AddLayer(mitk::Image::Pointer layerImage, mitk::LabelSet::Pointer lset)
+unsigned int mitk::LabelSetImage::AddLayer(mitk::Image::Pointer layerImage, mitk::LabelSet::Pointer labelSet)
 {
   unsigned int newLabelSetId = m_LayerContainer.size();
 
   // Add labelset to layer
   mitk::LabelSet::Pointer ls;
-  if (lset.IsNotNull())
+  if (labelSet.IsNotNull())
   {
-    ls = lset;
+    ls = labelSet;
   }
   else
   {
     ls = mitk::LabelSet::New();
     ls->AddLabel(GetExteriorLabel());
     ls->SetActiveLabel(0 /*Exterior Label*/);
   }
 
   ls->SetLayer(newLabelSetId);
   // Add exterior Label to label set
   // mitk::Label::Pointer exteriorLabel = CreateExteriorLabel();
 
   // push a new working image for the new layer
   m_LayerContainer.push_back(layerImage);
 
   // push a new labelset for the new layer
   m_LabelSetContainer.push_back(ls);
 
   // add modified event listener to LabelSet (listen to LabelSet changes)
   itk::SimpleMemberCommand<Self>::Pointer command = itk::SimpleMemberCommand<Self>::New();
   command->SetCallbackFunction(this, &mitk::LabelSetImage::OnLabelSetModified);
   ls->AddObserver(itk::ModifiedEvent(), command);
 
   SetActiveLayer(newLabelSetId);
   // MITK_INFO << GetActiveLayer();
   this->Modified();
   return newLabelSetId;
 }
 
 void mitk::LabelSetImage::AddLabelSetToLayer(const unsigned int layerIdx, const mitk::LabelSet::Pointer labelSet)
 {
   if (m_LayerContainer.size() <= layerIdx)
   {
     mitkThrow() << "Trying to add labelSet to non-existing layer.";
   }
 
   if (layerIdx < m_LabelSetContainer.size())
   {
     m_LabelSetContainer[layerIdx] = labelSet;
   }
   else
   {
     while (layerIdx >= m_LabelSetContainer.size())
     {
       mitk::LabelSet::Pointer defaultLabelSet = mitk::LabelSet::New();
       defaultLabelSet->AddLabel(GetExteriorLabel());
       defaultLabelSet->SetActiveLabel(0 /*Exterior Label*/);
       defaultLabelSet->SetLayer(m_LabelSetContainer.size());
       m_LabelSetContainer.push_back(defaultLabelSet);
     }
     m_LabelSetContainer.push_back(labelSet);
   }
 }
 
 void mitk::LabelSetImage::SetActiveLayer(unsigned int layer)
 {
   try
   {
     if (4 == this->GetDimension())
     {
       if ((layer != GetActiveLayer() || m_activeLayerInvalid) && (layer < this->GetNumberOfLayers()))
       {
         BeforeChangeLayerEvent.Send();
 
         if (m_activeLayerInvalid)
         {
           // We should not write the invalid layer back to the vector
           m_activeLayerInvalid = false;
         }
         else
         {
           AccessFixedDimensionByItk_n(this, ImageToLayerContainerProcessing, 4, (GetActiveLayer()));
         }
         m_ActiveLayer = layer; // only at this place m_ActiveLayer should be manipulated!!! Use Getter and Setter
         AccessFixedDimensionByItk_n(this, LayerContainerToImageProcessing, 4, (GetActiveLayer()));
 
         AfterChangeLayerEvent.Send();
       }
     }
     else
     {
       if ((layer != GetActiveLayer() || m_activeLayerInvalid) && (layer < this->GetNumberOfLayers()))
       {
         BeforeChangeLayerEvent.Send();
 
         if (m_activeLayerInvalid)
         {
           // We should not write the invalid layer back to the vector
           m_activeLayerInvalid = false;
         }
         else
         {
           AccessByItk_1(this, ImageToLayerContainerProcessing, GetActiveLayer());
         }
         m_ActiveLayer = layer; // only at this place m_ActiveLayer should be manipulated!!! Use Getter and Setter
         AccessByItk_1(this, LayerContainerToImageProcessing, GetActiveLayer());
 
         AfterChangeLayerEvent.Send();
       }
     }
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   this->Modified();
 }
 
-void mitk::LabelSetImage::Concatenate(mitk::LabelSetImage *other)
-{
-  const unsigned int *otherDims = other->GetDimensions();
-  const unsigned int *thisDims = this->GetDimensions();
-  if ((otherDims[0] != thisDims[0]) || (otherDims[1] != thisDims[1]) || (otherDims[2] != thisDims[2]))
-    mitkThrow() << "Dimensions do not match.";
-
-  try
-  {
-    int numberOfLayers = other->GetNumberOfLayers();
-    for (int layer = 0; layer < numberOfLayers; ++layer)
-    {
-      this->SetActiveLayer(layer);
-      AccessByItk_1(this, ConcatenateProcessing, other);
-      mitk::LabelSet *ls = other->GetLabelSet(layer);
-      auto it = ls->IteratorConstBegin();
-      auto end = ls->IteratorConstEnd();
-      it++; // skip exterior
-      while (it != end)
-      {
-        GetLabelSet()->AddLabel((it->second));
-        // AddLabelEvent.Send();
-        it++;
-      }
-    }
-  }
-  catch (itk::ExceptionObject &e)
-  {
-    mitkThrow() << e.GetDescription();
-  }
-  this->Modified();
-}
-
 void mitk::LabelSetImage::ClearBuffer()
 {
   try
   {
     if (this->GetDimension() == 4)
     { //remark: this extra branch was added, because LabelSetImage instances can be
       //dynamic (4D), but AccessByItk by support only supports 2D and 3D.
       //The option to change the CMake default dimensions for AccessByItk was
       //dropped (for details see discussion in T28756)
       AccessFixedDimensionByItk(this, ClearBufferProcessing,4);
     }
     else
     {
       AccessByItk(this, ClearBufferProcessing);
     }
     this->Modified();
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
 }
 
 bool mitk::LabelSetImage::ExistLabel(PixelType pixelValue) const
 {
   bool exist = false;
   for (unsigned int lidx = 0; lidx < GetNumberOfLayers(); lidx++)
     exist |= m_LabelSetContainer[lidx]->ExistLabel(pixelValue);
   return exist;
 }
 
 bool mitk::LabelSetImage::ExistLabel(PixelType pixelValue, unsigned int layer) const
 {
   bool exist = m_LabelSetContainer[layer]->ExistLabel(pixelValue);
   return exist;
 }
 
 bool mitk::LabelSetImage::ExistLabelSet(unsigned int layer) const
 {
   return layer < m_LabelSetContainer.size();
 }
 
 void mitk::LabelSetImage::MergeLabel(PixelType pixelValue, PixelType sourcePixelValue, unsigned int layer)
 {
   try
   {
     AccessByItk_2(this, MergeLabelProcessing, pixelValue, sourcePixelValue);
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   GetLabelSet(layer)->SetActiveLabel(pixelValue);
   Modified();
 }
 
 void mitk::LabelSetImage::MergeLabels(PixelType pixelValue, std::vector<PixelType>& vectorOfSourcePixelValues, unsigned int layer)
 {
   try
   {
     for (unsigned int idx = 0; idx < vectorOfSourcePixelValues.size(); idx++)
     {
       AccessByItk_2(this, MergeLabelProcessing, pixelValue, vectorOfSourcePixelValues[idx]);
     }
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   GetLabelSet(layer)->SetActiveLabel(pixelValue);
   Modified();
 }
 
-void mitk::LabelSetImage::RemoveLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer)
+void mitk::LabelSetImage::RemoveLabel(PixelType pixelValue, unsigned int layer)
 {
-  for (unsigned int idx = 0; idx < VectorOfLabelPixelValues.size(); idx++)
-  {
-    GetLabelSet(layer)->RemoveLabel(VectorOfLabelPixelValues[idx]);
-    EraseLabel(VectorOfLabelPixelValues[idx], layer);
-  }
+  this->GetLabelSet(layer)->RemoveLabel(pixelValue);
+  this->EraseLabel(pixelValue);
 }
 
-void mitk::LabelSetImage::EraseLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer)
+void mitk::LabelSetImage::RemoveLabels(std::vector<PixelType>& VectorOfLabelPixelValues, unsigned int layer)
 {
-  for (unsigned int i = 0; i < VectorOfLabelPixelValues.size(); i++)
+  for (unsigned int idx = 0; idx < VectorOfLabelPixelValues.size(); idx++)
   {
-    this->EraseLabel(VectorOfLabelPixelValues[i], layer);
+    this->RemoveLabel(VectorOfLabelPixelValues[idx], layer);
   }
 }
 
-void mitk::LabelSetImage::EraseLabel(PixelType pixelValue, unsigned int layer)
+void mitk::LabelSetImage::EraseLabel(PixelType pixelValue)
 {
   try
   {
     if (4 == this->GetDimension())
     {
-      AccessFixedDimensionByItk_2(this, EraseLabelProcessing, 4, pixelValue, layer);
+      AccessFixedDimensionByItk_1(this, EraseLabelProcessing, 4, pixelValue);
     }
     else
     {
-      AccessByItk_2(this, EraseLabelProcessing, pixelValue, layer);
+      AccessByItk_1(this, EraseLabelProcessing, pixelValue);
     }
   }
-  catch (const itk::ExceptionObject &e)
+  catch (const itk::ExceptionObject& e)
   {
     mitkThrow() << e.GetDescription();
   }
   Modified();
 }
 
+void mitk::LabelSetImage::EraseLabels(std::vector<PixelType>& VectorOfLabelPixelValues)
+{
+  for (unsigned int idx = 0; idx < VectorOfLabelPixelValues.size(); idx++)
+  {
+    this->EraseLabel(VectorOfLabelPixelValues[idx]);
+  }
+}
+
 mitk::Label *mitk::LabelSetImage::GetActiveLabel(unsigned int layer)
 {
   if (m_LabelSetContainer.size() <= layer)
     return nullptr;
   else
     return m_LabelSetContainer[layer]->GetActiveLabel();
 }
 
 const mitk::Label* mitk::LabelSetImage::GetActiveLabel(unsigned int layer) const
 {
   if (m_LabelSetContainer.size() <= layer)
     return nullptr;
   else
     return m_LabelSetContainer[layer]->GetActiveLabel();
 }
 
 mitk::Label *mitk::LabelSetImage::GetLabel(PixelType pixelValue, unsigned int layer) const
 {
   if (m_LabelSetContainer.size() <= layer)
     return nullptr;
   else
     return m_LabelSetContainer[layer]->GetLabel(pixelValue);
 }
 
 mitk::LabelSet *mitk::LabelSetImage::GetLabelSet(unsigned int layer)
 {
   if (m_LabelSetContainer.size() <= layer)
     return nullptr;
   else
     return m_LabelSetContainer[layer].GetPointer();
 }
 
 const mitk::LabelSet *mitk::LabelSetImage::GetLabelSet(unsigned int layer) const
 {
   if (m_LabelSetContainer.size() <= layer)
     return nullptr;
   else
     return m_LabelSetContainer[layer].GetPointer();
 }
 
 mitk::LabelSet *mitk::LabelSetImage::GetActiveLabelSet()
 {
   if (m_LabelSetContainer.size() == 0)
     return nullptr;
   else
     return m_LabelSetContainer[GetActiveLayer()].GetPointer();
 }
 
 const mitk::LabelSet* mitk::LabelSetImage::GetActiveLabelSet() const
 {
   if (m_LabelSetContainer.size() == 0)
     return nullptr;
   else
     return m_LabelSetContainer[GetActiveLayer()].GetPointer();
 }
 
 void mitk::LabelSetImage::UpdateCenterOfMass(PixelType pixelValue, unsigned int layer)
 {
   if (4 == this->GetDimension())
   {
     AccessFixedDimensionByItk_2(this, CalculateCenterOfMassProcessing, 4, pixelValue, layer);
   }
   else
   {
     AccessByItk_2(this, CalculateCenterOfMassProcessing, pixelValue, layer);
   }
 }
 
 unsigned int mitk::LabelSetImage::GetNumberOfLabels(unsigned int layer) const
 {
   return m_LabelSetContainer[layer]->GetNumberOfLabels();
 }
 
 unsigned int mitk::LabelSetImage::GetTotalNumberOfLabels() const
 {
   unsigned int totalLabels(0);
   auto layerIter = m_LabelSetContainer.begin();
   for (; layerIter != m_LabelSetContainer.end(); ++layerIter)
     totalLabels += (*layerIter)->GetNumberOfLabels();
   return totalLabels;
 }
 
 void mitk::LabelSetImage::MaskStamp(mitk::Image *mask, bool forceOverwrite)
 {
   try
   {
     mitk::PadImageFilter::Pointer padImageFilter = mitk::PadImageFilter::New();
     padImageFilter->SetInput(0, mask);
     padImageFilter->SetInput(1, this);
     padImageFilter->SetPadConstant(0);
     padImageFilter->SetBinaryFilter(false);
     padImageFilter->SetLowerThreshold(0);
     padImageFilter->SetUpperThreshold(1);
 
     padImageFilter->Update();
 
     mitk::Image::Pointer paddedMask = padImageFilter->GetOutput();
 
     if (paddedMask.IsNull())
       return;
 
     AccessByItk_2(this, MaskStampProcessing, paddedMask, forceOverwrite);
   }
   catch (...)
   {
     mitkThrow() << "Could not stamp the provided mask on the selected label.";
   }
 }
 
 mitk::Image::Pointer mitk::LabelSetImage::CreateLabelMask(PixelType index, bool useActiveLayer, unsigned int layer)
 {
   auto previousActiveLayer = this->GetActiveLayer();
   auto mask = mitk::Image::New();
 
   try
   {
     // mask->Initialize(this) does not work here if this label set image has a single slice,
     // since the mask would be automatically flattened to a 2-d image, whereas we expect the
     // original dimension of this label set image. Hence, initialize the mask more explicitly:
     mask->Initialize(this->GetPixelType(), this->GetDimension(), this->GetDimensions());
     mask->SetTimeGeometry(this->GetTimeGeometry()->Clone());
 
     auto byteSize = sizeof(LabelSetImage::PixelType);
     for (unsigned int dim = 0; dim < mask->GetDimension(); ++dim)
       byteSize *= mask->GetDimension(dim);
 
     {
       ImageWriteAccessor accessor(mask);
       memset(accessor.GetData(), 0, byteSize);
     }
 
     if (!useActiveLayer)
       this->SetActiveLayer(layer);
 
     if (4 == this->GetDimension())
     {
       ::CreateLabelMaskProcessing<4>(this, mask, index);
     }
     else if (3 == this->GetDimension())
     {
       ::CreateLabelMaskProcessing(this, mask, index);
     }
     else
     {
       mitkThrow();
     }
   }
   catch (...)
   {
     if (!useActiveLayer)
       this->SetActiveLayer(previousActiveLayer);
 
     mitkThrow() << "Could not create a mask out of the selected label.";
   }
 
   if (!useActiveLayer)
     this->SetActiveLayer(previousActiveLayer);
 
   return mask;
 }
 
 void mitk::LabelSetImage::InitializeByLabeledImage(mitk::Image::Pointer image)
 {
   if (image.IsNull() || image->IsEmpty() || !image->IsInitialized())
     mitkThrow() << "Invalid labeled image.";
 
   try
   {
     this->Initialize(image);
 
     unsigned int byteSize = sizeof(LabelSetImage::PixelType);
     for (unsigned int dim = 0; dim < image->GetDimension(); ++dim)
     {
       byteSize *= image->GetDimension(dim);
     }
 
     mitk::ImageWriteAccessor *accessor = new mitk::ImageWriteAccessor(static_cast<mitk::Image *>(this));
     memset(accessor->GetData(), 0, byteSize);
     delete accessor;
 
     auto geometry = image->GetTimeGeometry()->Clone();
     this->SetTimeGeometry(geometry);
 
     if (image->GetDimension() == 3)
     {
       AccessTwoImagesFixedDimensionByItk(this, image, InitializeByLabeledImageProcessing, 3);
     }
     else if (image->GetDimension() == 4)
     {
       AccessTwoImagesFixedDimensionByItk(this, image, InitializeByLabeledImageProcessing, 4);
     }
     else
     {
       mitkThrow() << image->GetDimension() << "-dimensional label set images not yet supported";
     }
   }
   catch (...)
   {
     mitkThrow() << "Could not intialize by provided labeled image.";
   }
   this->Modified();
 }
 
 template <typename LabelSetImageType, typename ImageType>
 void mitk::LabelSetImage::InitializeByLabeledImageProcessing(LabelSetImageType *labelSetImage, ImageType *image)
 {
   typedef itk::ImageRegionConstIteratorWithIndex<ImageType> SourceIteratorType;
   typedef itk::ImageRegionIterator<LabelSetImageType> TargetIteratorType;
 
   TargetIteratorType targetIter(labelSetImage, labelSetImage->GetRequestedRegion());
   targetIter.GoToBegin();
 
   SourceIteratorType sourceIter(image, image->GetRequestedRegion());
   sourceIter.GoToBegin();
 
   while (!sourceIter.IsAtEnd())
   {
     auto sourceValue = static_cast<PixelType>(sourceIter.Get());
     targetIter.Set(sourceValue);
 
     if (!this->ExistLabel(sourceValue))
     {
       std::stringstream name;
       name << "object-" << sourceValue;
 
       double rgba[4];
       m_LabelSetContainer[this->GetActiveLayer()]->GetLookupTable()->GetTableValue(sourceValue, rgba);
 
       mitk::Color color;
       color.SetRed(rgba[0]);
       color.SetGreen(rgba[1]);
       color.SetBlue(rgba[2]);
 
       auto label = mitk::Label::New();
       label->SetName(name.str().c_str());
       label->SetColor(color);
       label->SetOpacity(rgba[3]);
       label->SetValue(sourceValue);
 
       this->GetLabelSet()->AddLabel(label);
 
       if (GetActiveLabelSet()->GetNumberOfLabels() >= mitk::Label::MAX_LABEL_VALUE ||
           sourceValue >= mitk::Label::MAX_LABEL_VALUE)
         this->AddLayer();
     }
 
     ++sourceIter;
     ++targetIter;
   }
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::MaskStampProcessing(ImageType *itkImage, mitk::Image *mask, bool forceOverwrite)
 {
   typename ImageType::Pointer itkMask;
   mitk::CastToItkImage(mask, itkMask);
 
   typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
   typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
 
   SourceIteratorType sourceIter(itkMask, itkMask->GetLargestPossibleRegion());
   sourceIter.GoToBegin();
 
   TargetIteratorType targetIter(itkImage, itkImage->GetLargestPossibleRegion());
   targetIter.GoToBegin();
 
   int activeLabel = this->GetActiveLabel(GetActiveLayer())->GetValue();
 
   while (!sourceIter.IsAtEnd())
   {
     PixelType sourceValue = sourceIter.Get();
     PixelType targetValue = targetIter.Get();
 
     if ((sourceValue != 0) &&
         (forceOverwrite || !this->GetLabel(targetValue)->GetLocked())) // skip exterior and locked labels
     {
       targetIter.Set(activeLabel);
     }
     ++sourceIter;
     ++targetIter;
   }
 
   this->Modified();
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::CalculateCenterOfMassProcessing(ImageType *itkImage, PixelType pixelValue, unsigned int layer)
 {
   // for now, we just retrieve the voxel in the middle
   typedef itk::ImageRegionConstIterator<ImageType> IteratorType;
   IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
   iter.GoToBegin();
 
   std::vector<typename ImageType::IndexType> indexVector;
 
   while (!iter.IsAtEnd())
   {
     // TODO fix comparison warning more effective
     if (iter.Get() == pixelValue)
     {
       indexVector.push_back(iter.GetIndex());
     }
     ++iter;
   }
 
   mitk::Point3D pos;
   pos.Fill(0.0);
 
   if (!indexVector.empty())
   {
     typename itk::ImageRegionConstIteratorWithIndex<ImageType>::IndexType centerIndex;
     centerIndex = indexVector.at(indexVector.size() / 2);
     if (centerIndex.GetIndexDimension() == 3)
     {
       pos[0] = centerIndex[0];
       pos[1] = centerIndex[1];
       pos[2] = centerIndex[2];
     }
     else
       return;
   }
 
   GetLabelSet(layer)->GetLabel(pixelValue)->SetCenterOfMassIndex(pos);
   this->GetSlicedGeometry()->IndexToWorld(pos, pos); // TODO: TimeGeometry?
   GetLabelSet(layer)->GetLabel(pixelValue)->SetCenterOfMassCoordinates(pos);
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::ClearBufferProcessing(ImageType *itkImage)
 {
   itkImage->FillBuffer(0);
 }
 
-// todo: concatenate all layers and not just the active one
-template <typename ImageType>
-void mitk::LabelSetImage::ConcatenateProcessing(ImageType *itkTarget, mitk::LabelSetImage *other)
-{
-  typename ImageType::Pointer itkSource = ImageType::New();
-  mitk::CastToItkImage(other, itkSource);
-
-  typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
-  typedef itk::ImageRegionIterator<ImageType> IteratorType;
-
-  ConstIteratorType sourceIter(itkSource, itkSource->GetLargestPossibleRegion());
-  IteratorType targetIter(itkTarget, itkTarget->GetLargestPossibleRegion());
-
-  int numberOfTargetLabels = this->GetNumberOfLabels(GetActiveLayer()) - 1; // skip exterior
-  sourceIter.GoToBegin();
-  targetIter.GoToBegin();
-
-  while (!sourceIter.IsAtEnd())
-  {
-    PixelType sourceValue = sourceIter.Get();
-    PixelType targetValue = targetIter.Get();
-    if ((sourceValue != 0) && !this->GetLabel(targetValue)->GetLocked()) // skip exterior and locked labels
-    {
-      targetIter.Set(sourceValue + numberOfTargetLabels);
-    }
-    ++sourceIter;
-    ++targetIter;
-  }
-}
-
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::LabelSetImage::LayerContainerToImageProcessing(itk::Image<TPixel, VImageDimension> *target,
                                                           unsigned int layer)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typename ImageType::Pointer itkSource;
   // mitk::CastToItkImage(m_LayerContainer[layer], itkSource);
   itkSource = ImageToItkImage<TPixel, VImageDimension>(m_LayerContainer[layer]);
   typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
   typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
 
   SourceIteratorType sourceIter(itkSource, itkSource->GetLargestPossibleRegion());
   sourceIter.GoToBegin();
 
   TargetIteratorType targetIter(target, target->GetLargestPossibleRegion());
   targetIter.GoToBegin();
 
   while (!sourceIter.IsAtEnd())
   {
     targetIter.Set(sourceIter.Get());
     ++sourceIter;
     ++targetIter;
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::LabelSetImage::ImageToLayerContainerProcessing(itk::Image<TPixel, VImageDimension> *source,
                                                           unsigned int layer) const
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typename ImageType::Pointer itkTarget;
   // mitk::CastToItkImage(m_LayerContainer[layer], itkTarget);
   itkTarget = ImageToItkImage<TPixel, VImageDimension>(m_LayerContainer[layer]);
 
   typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
   typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
 
   SourceIteratorType sourceIter(source, source->GetLargestPossibleRegion());
   sourceIter.GoToBegin();
 
   TargetIteratorType targetIter(itkTarget, itkTarget->GetLargestPossibleRegion());
   targetIter.GoToBegin();
 
   while (!sourceIter.IsAtEnd())
   {
     targetIter.Set(sourceIter.Get());
     ++sourceIter;
     ++targetIter;
   }
 }
 
 template <typename ImageType>
-void mitk::LabelSetImage::EraseLabelProcessing(ImageType *itkImage, PixelType pixelValue, unsigned int /*layer*/)
+void mitk::LabelSetImage::EraseLabelProcessing(ImageType *itkImage, PixelType pixelValue)
 {
   typedef itk::ImageRegionIterator<ImageType> IteratorType;
 
   IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
   iter.GoToBegin();
 
   while (!iter.IsAtEnd())
   {
     PixelType value = iter.Get();
 
     if (value == pixelValue)
     {
       iter.Set(0);
     }
     ++iter;
   }
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::MergeLabelProcessing(ImageType *itkImage, PixelType pixelValue, PixelType index)
 {
   typedef itk::ImageRegionIterator<ImageType> IteratorType;
 
   IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
   iter.GoToBegin();
 
   while (!iter.IsAtEnd())
   {
     if (iter.Get() == index)
     {
       iter.Set(pixelValue);
     }
     ++iter;
   }
 }
 
 bool mitk::Equal(const mitk::LabelSetImage &leftHandSide,
                  const mitk::LabelSetImage &rightHandSide,
                  ScalarType eps,
                  bool verbose)
 {
   bool returnValue = true;
 
   /* LabelSetImage members */
 
   MITK_INFO(verbose) << "--- LabelSetImage Equal ---";
 
   // number layers
   returnValue = leftHandSide.GetNumberOfLayers() == rightHandSide.GetNumberOfLayers();
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Number of layers not equal.";
     return false;
   }
 
   // total number labels
   returnValue = leftHandSide.GetTotalNumberOfLabels() == rightHandSide.GetTotalNumberOfLabels();
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Total number of labels not equal.";
     return false;
   }
 
   // active layer
   returnValue = leftHandSide.GetActiveLayer() == rightHandSide.GetActiveLayer();
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Active layer not equal.";
     return false;
   }
 
   if (4 == leftHandSide.GetDimension())
   {
     MITK_INFO(verbose) << "Can not compare image data for 4D images - skipping check.";
   }
   else
   {
     // working image data
     returnValue = mitk::Equal((const mitk::Image &)leftHandSide, (const mitk::Image &)rightHandSide, eps, verbose);
     if (!returnValue)
     {
       MITK_INFO(verbose) << "Working image data not equal.";
       return false;
     }
   }
 
   for (unsigned int layerIndex = 0; layerIndex < leftHandSide.GetNumberOfLayers(); layerIndex++)
   {
     if (4 == leftHandSide.GetDimension())
     {
       MITK_INFO(verbose) << "Can not compare image data for 4D images - skipping check.";
     }
     else
     {
       // layer image data
       returnValue =
         mitk::Equal(*leftHandSide.GetLayerImage(layerIndex), *rightHandSide.GetLayerImage(layerIndex), eps, verbose);
       if (!returnValue)
       {
         MITK_INFO(verbose) << "Layer image data not equal.";
         return false;
       }
     }
     // layer labelset data
 
     returnValue =
       mitk::Equal(*leftHandSide.GetLabelSet(layerIndex), *rightHandSide.GetLabelSet(layerIndex), eps, verbose);
     if (!returnValue)
     {
       MITK_INFO(verbose) << "Layer labelset data not equal.";
       return false;
     }
   }
 
   return returnValue;
 }
+
+/** Functor class that implements the label transfer and is used in conjunction with the itk::BinaryFunctorImageFilter.
+* For details regarding the usage of the filter and the functor patterns, please see info of itk::BinaryFunctorImageFilter.
+*/
+template <class TDestinationPixel, class TSourcePixel, class TOutputpixel>
+class LabelTransferFunctor
+{
+
+public:
+  LabelTransferFunctor() {};
+
+  LabelTransferFunctor(const mitk::LabelSet* destinationLabelSet, mitk::Label::PixelType sourceBackground,
+    mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked,
+    mitk::Label::PixelType sourceLabel, mitk::Label::PixelType newDestinationLabel, mitk::MultiLabelSegmentation::MergeStyle mergeStyle,
+    mitk::MultiLabelSegmentation::OverwriteStyle overwriteStyle) :
+    m_DestinationLabelSet(destinationLabelSet), m_SourceBackground(sourceBackground),
+    m_DestinationBackground(destinationBackground), m_DestinationBackgroundLocked(destinationBackgroundLocked),
+    m_SourceLabel(sourceLabel), m_NewDestinationLabel(newDestinationLabel), m_MergeStyle(mergeStyle), m_OverwriteStyle(overwriteStyle)
+  {
+  };
+
+  ~LabelTransferFunctor() {};
+
+  bool operator!=(const LabelTransferFunctor& other)const
+  {
+    return !(*this == other);
+  }
+  bool operator==(const LabelTransferFunctor& other) const
+  {
+    return this->m_SourceBackground == other.m_SourceBackground &&
+      this->m_DestinationBackground == other.m_DestinationBackground &&
+      this->m_DestinationBackgroundLocked == other.m_DestinationBackgroundLocked &&
+      this->m_SourceLabel == other.m_SourceLabel &&
+      this->m_NewDestinationLabel == other.m_NewDestinationLabel &&
+      this->m_MergeStyle == other.m_MergeStyle &&
+      this->m_OverwriteStyle == other.m_OverwriteStyle &&
+      this->m_DestinationLabelSet == other.m_DestinationLabelSet;
+  }
+
+  LabelTransferFunctor& operator=(const LabelTransferFunctor& other)
+  {
+    this->m_DestinationLabelSet = other.m_DestinationLabelSet;
+    this->m_SourceBackground = other.m_SourceBackground;
+    this->m_DestinationBackground = other.m_DestinationBackground;
+    this->m_DestinationBackgroundLocked = other.m_DestinationBackgroundLocked;
+    this->m_SourceLabel = other.m_SourceLabel;
+    this->m_NewDestinationLabel = other.m_NewDestinationLabel;
+    this->m_MergeStyle = other.m_MergeStyle;
+    this->m_OverwriteStyle = other.m_OverwriteStyle;
+
+    return *this;
+  }
+
+  inline TOutputpixel operator()(const TDestinationPixel& existingDestinationValue, const TSourcePixel& existingSourceValue)
+  {
+    if (existingSourceValue == this->m_SourceLabel)
+    {
+      if (mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks == this->m_OverwriteStyle)
+      {
+        return this->m_NewDestinationLabel;
+      }
+      else
+      {
+        auto label = this->m_DestinationLabelSet->GetLabel(existingDestinationValue);
+        if (nullptr == label || !label->GetLocked())
+        {
+          return this->m_NewDestinationLabel;
+        }
+      }
+    }
+    else if (mitk::MultiLabelSegmentation::MergeStyle::Replace == this->m_MergeStyle
+      && existingSourceValue == this->m_SourceBackground
+      && existingDestinationValue == this->m_NewDestinationLabel
+      && (mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks == this->m_OverwriteStyle
+          || !this->m_DestinationBackgroundLocked))
+    {
+      return this->m_DestinationBackground;
+    }
+
+    return existingDestinationValue;
+  }
+
+private:
+  const mitk::LabelSet* m_DestinationLabelSet = nullptr;
+  mitk::Label::PixelType m_SourceBackground = 0;
+  mitk::Label::PixelType m_DestinationBackground = 0;
+  bool m_DestinationBackgroundLocked = false;
+  mitk::Label::PixelType m_SourceLabel = 1;
+  mitk::Label::PixelType m_NewDestinationLabel = 1;
+  mitk::MultiLabelSegmentation::MergeStyle m_MergeStyle = mitk::MultiLabelSegmentation::MergeStyle::Replace;
+  mitk::MultiLabelSegmentation::OverwriteStyle m_OverwriteStyle = mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks;
+};
+
+/**Helper function used by TransferLabelContent to allow the templating over different image dimensions in conjunction of AccessFixedPixelTypeByItk_n.*/
+template<unsigned int VImageDimension>
+void TransferLabelContentHelper(const itk::Image<mitk::Label::PixelType, VImageDimension>* itkSourceImage, mitk::Image* destinationImage,
+  const mitk::LabelSet* destinationLabelSet, mitk::Label::PixelType sourceBackground, mitk::Label::PixelType destinationBackground,
+  bool destinationBackgroundLocked, mitk::Label::PixelType sourceLabel, mitk::Label::PixelType newDestinationLabel, mitk::MultiLabelSegmentation::MergeStyle mergeStyle, mitk::MultiLabelSegmentation::OverwriteStyle overwriteStyle)
+{
+  typedef itk::Image<mitk::Label::PixelType, VImageDimension> ContentImageType;
+  typename ContentImageType::Pointer itkDestinationImage;
+  mitk::CastToItkImage(destinationImage, itkDestinationImage);
+
+  typedef LabelTransferFunctor <mitk::Label::PixelType, mitk::Label::PixelType, mitk::Label::PixelType> LabelTransferFunctorType;
+  typedef itk::BinaryFunctorImageFilter<ContentImageType, ContentImageType, ContentImageType, LabelTransferFunctorType> FilterType;
+
+  LabelTransferFunctorType transferFunctor(destinationLabelSet, sourceBackground, destinationBackground,
+    destinationBackgroundLocked, sourceLabel, newDestinationLabel, mergeStyle, overwriteStyle);
+
+  auto transferFilter = FilterType::New();
+
+  transferFilter->SetFunctor(transferFunctor);
+  transferFilter->InPlaceOn();
+  transferFilter->SetInput1(itkDestinationImage);
+  transferFilter->SetInput2(itkSourceImage);
+
+  transferFilter->Update();
+}
+
+void mitk::TransferLabelContent(
+  const Image* sourceImage, Image* destinationImage, const mitk::LabelSet* destinationLabelSet, mitk::Label::PixelType sourceBackground,
+  mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked, std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping,
+  MultiLabelSegmentation::MergeStyle mergeStyle, MultiLabelSegmentation::OverwriteStyle overwriteStlye, const TimeStepType timeStep)
+{
+  if (nullptr == sourceImage)
+  {
+    mitkThrow() << "Invalid call of TransferLabelContent; sourceImage must not be null.";
+  }
+  if (nullptr == destinationImage)
+  {
+    mitkThrow() << "Invalid call of TransferLabelContent; destinationImage must not be null.";
+  }
+  if (nullptr == destinationLabelSet)
+  {
+    mitkThrow() << "Invalid call of TransferLabelContent; destinationLabelSet must not be null";
+  }
+
+  Image::ConstPointer sourceImageAtTimeStep = SelectImageByTimeStep(sourceImage, timeStep);
+  Image::Pointer destinationImageAtTimeStep = SelectImageByTimeStep(destinationImage, timeStep);
+
+  if (nullptr == sourceImageAtTimeStep)
+  {
+    mitkThrow() << "Invalid call of TransferLabelContent; sourceImage does not have the requested time step: " << timeStep;
+  }
+  if (nullptr == destinationImageAtTimeStep)
+  {
+    mitkThrow() << "Invalid call of TransferLabelContent; destinationImage does not have the requested time step: " << timeStep;
+  }
+
+  for (const auto& [sourceLabel, newDestinationLabel] : labelMapping)
+  {
+    if (nullptr == destinationLabelSet->GetLabel(newDestinationLabel))
+    {
+      mitkThrow() << "Invalid call of TransferLabelContent. Defined destination label does not exist in destinationImage. newDestinationLabel: " << newDestinationLabel;
+    }
+
+    AccessFixedPixelTypeByItk_n(sourceImageAtTimeStep, TransferLabelContentHelper, (Label::PixelType), (destinationImageAtTimeStep, destinationLabelSet, sourceBackground, destinationBackground, destinationBackgroundLocked, sourceLabel, newDestinationLabel, mergeStyle, overwriteStlye));
+  }
+  destinationImage->Modified();
+}
+
+void mitk::TransferLabelContent(
+  const LabelSetImage* sourceImage, LabelSetImage* destinationImage, std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping,
+  MultiLabelSegmentation::MergeStyle mergeStyle, MultiLabelSegmentation::OverwriteStyle overwriteStlye, const TimeStepType timeStep)
+{
+  if (nullptr == sourceImage)
+  {
+    mitkThrow() << "Invalid call of TransferLabelContent; sourceImage must not be null.";
+  }
+
+  const auto sourceBackground = sourceImage->GetExteriorLabel()->GetValue();
+  const auto destinationBackground = destinationImage->GetExteriorLabel()->GetValue();
+  const auto destinationBackgroundLocked = destinationImage->GetExteriorLabel()->GetLocked();
+  const auto destinationLabelSet = destinationImage->GetLabelSet(destinationImage->GetActiveLayer());
+
+  for (const auto& mappingElement : labelMapping)
+  {
+    if (!sourceImage->ExistLabel(mappingElement.first, sourceImage->GetActiveLayer()))
+    {
+      mitkThrow() << "Invalid call of TransferLabelContent. Defined source label does not exist in sourceImage. SourceLabel: " << mappingElement.first;
+    }
+  }
+
+  TransferLabelContent(sourceImage, destinationImage, destinationLabelSet, sourceBackground, destinationBackground, destinationBackgroundLocked,
+    labelMapping, mergeStyle, overwriteStlye, timeStep);
+}
diff --git a/Modules/Multilabel/mitkLabelSetImage.h b/Modules/Multilabel/mitkLabelSetImage.h
index 2d02b05287..491b80ca67 100644
--- a/Modules/Multilabel/mitkLabelSetImage.h
+++ b/Modules/Multilabel/mitkLabelSetImage.h
@@ -1,342 +1,417 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef __mitkLabelSetImage_H_
 #define __mitkLabelSetImage_H_
 
 #include <mitkImage.h>
 #include <mitkLabelSet.h>
 
 #include <MitkMultilabelExports.h>
 
 namespace mitk
 {
   //##Documentation
   //## @brief LabelSetImage class for handling labels and layers in a segmentation session.
   //##
   //## Handles operations for adding, removing, erasing and editing labels and layers.
   //## @ingroup Data
 
   class MITKMULTILABEL_EXPORT LabelSetImage : public Image
   {
   public:
     mitkClassMacro(LabelSetImage, Image);
     itkNewMacro(Self);
 
       typedef mitk::Label::PixelType PixelType;
 
     /**
     * \brief BeforeChangeLayerEvent (e.g. used for GUI integration)
     * As soon as active labelset should be changed, the signal emits.
     * Emitted by SetActiveLayer(int layer);
     */
     Message<> BeforeChangeLayerEvent;
 
     /**
     * \brief AfterchangeLayerEvent (e.g. used for GUI integration)
     * As soon as active labelset was changed, the signal emits.
     * Emitted by SetActiveLayer(int layer);
     */
     Message<> AfterChangeLayerEvent;
 
     /**
      * @brief Initialize an empty mitk::LabelSetImage using the information
      *        of an mitk::Image
      * @param image the image which is used for initializing the mitk::LabelSetImage
      */
     using mitk::Image::Initialize;
     void Initialize(const mitk::Image *image) override;
 
-    /**
-      * \brief  */
-    void Concatenate(mitk::LabelSetImage *image);
-
     /**
       * \brief  */
     void ClearBuffer();
 
     /**
      * @brief Merges the mitk::Label with a given target value with the active label
      *
      * @param pixelValue          the value of the label that should be the new merged label
      * @param sourcePixelValue    the value of the label that should be merged into the specified one
      * @param layer               the layer in which the merge should be performed
      */
     void MergeLabel(PixelType pixelValue, PixelType sourcePixelValue, unsigned int layer = 0);
 
     /**
      * @brief Merges a list of mitk::Labels with the mitk::Label that has a specific value
      *
      * @param pixelValue                  the value of the label that should be the new merged label
      * @param vectorOfSourcePixelValues   the list of label values that should be merge into the specified one
      * @param layer                       the layer in which the merge should be performed
      */
     void MergeLabels(PixelType pixelValue, std::vector<PixelType>& vectorOfSourcePixelValues, unsigned int layer = 0);
 
     /**
       * \brief  */
     void UpdateCenterOfMass(PixelType pixelValue, unsigned int layer = 0);
 
     /**
-     * @brief Removes labels from the mitk::LabelSet of given layer.
-     *        Calls mitk::LabelSetImage::EraseLabels() which also removes the labels from within the image.
-     * @param VectorOfLabelPixelValues a list of labels to be removed
-     * @param layer the layer in which the labels should be removed
+     * @brief Removes the label with the given value.
+     *        The label is removed from the labelset of the given layer and
+     *        the pixel values of the image below the label are reset.
+     * @param pixelValue the pixel value of the label to be removed
+     * @param layer the layer from which the label should be removed
+     */
+    void RemoveLabel(PixelType pixelValue, unsigned int layer = 0);
+
+    /**
+     * @brief Removes a list of labels with th given value.
+     *        The labels are removed from the labelset of the given layer and
+     *        the pixel values of the image below the label are reset.
+     *        Calls mitk::LabelSetImage::EraseLabels().
+     * @param VectorOfLabelPixelValues a list of pixel values of labels to be removed
+     * @param layer the layer from which the labels should be removed
      */
     void RemoveLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer = 0);
 
     /**
-     * @brief Erases the label with the given value in the given layer from the underlying image.
+     * @brief Erases the label with the given value from the labelset image.
      *        The label itself will not be erased from the respective mitk::LabelSet. In order to
      *        remove the label itself use mitk::LabelSetImage::RemoveLabels()
-     * @param pixelValue the label which will be remove from the image
-     * @param layer the layer in which the label should be removed
+     * @param pixelValue the pixel value of the label that will be erased from the labelset image
      */
-    void EraseLabel(PixelType pixelValue, unsigned int layer = 0);
+    void EraseLabel(PixelType pixelValue);
 
     /**
-     * @brief Similar to mitk::LabelSetImage::EraseLabel() this funtion erase a list of labels from the image
-     * @param VectorOfLabelPixelValues the list of labels that should be remove
-     * @param layer the layer for which the labels should be removed
+     * @brief Erases a list of labels with the given values from the labelset image.
+     * @param VectorOfLabelPixelValues the list of pixel values of the labels
+     *                                 that will be erased from the labelset image
      */
-    void EraseLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer = 0);
+    void EraseLabels(std::vector<PixelType> &VectorOfLabelPixelValues);
 
     /**
       * \brief  Returns true if the value exists in one of the labelsets*/
     bool ExistLabel(PixelType pixelValue) const;
 
     /**
      * @brief Checks if a label exists in a certain layer
      * @param pixelValue the label value
      * @param layer the layer in which should be searched for the label
      * @return true if the label exists otherwise false
      */
     bool ExistLabel(PixelType pixelValue, unsigned int layer) const;
 
     /**
       * \brief  Returns true if the labelset exists*/
     bool ExistLabelSet(unsigned int layer) const;
 
     /**
      * @brief Returns the active label of a specific layer
      * @param layer the layer ID for which the active label should be returned
      * @return the active label of the specified layer
      */
     mitk::Label *GetActiveLabel(unsigned int layer = 0);
     const mitk::Label* GetActiveLabel(unsigned int layer = 0) const;
 
     /**
      * @brief Returns the mitk::Label with the given pixelValue and for the given layer
      * @param pixelValue the pixel value of the label
      * @param layer the layer in which the labels should be located
      * @return the mitk::Label if available otherwise nullptr
      */
     mitk::Label *GetLabel(PixelType pixelValue, unsigned int layer = 0) const;
 
     /**
      * @brief Returns the currently active mitk::LabelSet
      * @return the mitk::LabelSet of the active layer or nullptr if non is present
      */
     mitk::LabelSet *GetActiveLabelSet();
     const mitk::LabelSet* GetActiveLabelSet() const;
 
     /**
      * @brief Gets the mitk::LabelSet for the given layer
      * @param layer the layer for which the mitk::LabelSet should be retrieved
      * @return the respective mitk::LabelSet or nullptr if non exists for the given layer
      */
     mitk::LabelSet *GetLabelSet(unsigned int layer = 0);
     const mitk::LabelSet *GetLabelSet(unsigned int layer = 0) const;
 
     /**
      * @brief Gets the ID of the currently active layer
      * @return the ID of the active layer
      */
     unsigned int GetActiveLayer() const;
 
     /**
      * @brief Get the number of all existing mitk::Labels for a given layer
      * @param layer the layer ID for which the active mitk::Labels should be retrieved
      * @return the number of all existing mitk::Labels for the given layer
      */
     unsigned int GetNumberOfLabels(unsigned int layer = 0) const;
 
     /**
      * @brief Returns the number of all labels summed up across all layers
      * @return the overall number of labels across all layers
      */
     unsigned int GetTotalNumberOfLabels() const;
 
     // This function will need to be ported to an external class
     // it requires knowledge of pixeltype and dimension and includes
     // too much algorithm to be sensibly part of a data class
     ///**
     //  * \brief  */
     // void SurfaceStamp(mitk::Surface* surface, bool forceOverwrite);
 
     /**
       * \brief  */
     mitk::Image::Pointer CreateLabelMask(PixelType index, bool useActiveLayer = true, unsigned int layer = 0);
 
     /**
      * @brief Initialize a new mitk::LabelSetImage by an given image.
      * For all distinct pixel values of the parameter image new labels will
      * be created. If the number of distinct pixel values exceeds mitk::Label::MAX_LABEL_VALUE
      * a new layer will be created
      * @param image the image which is used for initialization
      */
     void InitializeByLabeledImage(mitk::Image::Pointer image);
 
     /**
       * \brief  */
     void MaskStamp(mitk::Image *mask, bool forceOverwrite);
 
     /**
       * \brief  */
     void SetActiveLayer(unsigned int layer);
 
     /**
       * \brief  */
     unsigned int GetNumberOfLayers() const;
 
     /**
-     * @brief Adds a new layer to the LabelSetImage. The new layer will be set as the active one
-     * @param layer a mitk::LabelSet which will be set as new layer.
-     * @return the layer ID of the new layer
+     * \brief Adds a new layer to the LabelSetImage. The new layer will be set as the active one.
+     * \param labelSet a labelset that will be added to the new layer if provided
+     * \return the layer ID of the new layer
      */
-    unsigned int AddLayer(mitk::LabelSet::Pointer layer = nullptr);
+    unsigned int AddLayer(mitk::LabelSet::Pointer labelSet = nullptr);
 
     /**
-    * \brief Add a layer based on a provided mitk::Image
+    * \brief Adds a layer based on a provided mitk::Image.
     * \param layerImage is added to the vector of label images
-    * \param lset a label set that will be added to the new layer if provided
-    *\return the layer ID of the new layer
+    * \param labelSet   a labelset that will be added to the new layer if provided
+    * \return the layer ID of the new layer
     */
-    unsigned int AddLayer(mitk::Image::Pointer layerImage, mitk::LabelSet::Pointer lset = nullptr);
+    unsigned int AddLayer(mitk::Image::Pointer layerImage, mitk::LabelSet::Pointer labelSet = nullptr);
 
     /**
     * \brief Add a LabelSet to an existing layer
     *
     * This will replace an existing labelSet if one exists. Throws an exceptions if you are trying
     * to add a labelSet to a non-existing layer.
     *
     * If there are no labelSets for layers with an id less than layerIdx default ones will be added
     * for them.
     *
     * \param layerIdx The index of the layer the LabelSet should be added to
     * \param labelSet The LabelSet that should be added
     */
     void AddLabelSetToLayer(const unsigned int layerIdx, const mitk::LabelSet::Pointer labelSet);
 
     /**
      * @brief Removes the active layer and the respective mitk::LabelSet and image information.
      *        The new active layer is the one below, if exists
      */
     void RemoveLayer();
 
     /**
       * \brief  */
     mitk::Image *GetLayerImage(unsigned int layer);
 
     const mitk::Image *GetLayerImage(unsigned int layer) const;
 
     void OnLabelSetModified();
 
     /**
      * @brief Sets the label which is used as default exterior label when creating a new layer
      * @param label the label which will be used as new exterior label
      */
     void SetExteriorLabel(mitk::Label *label);
 
     /**
      * @brief Gets the mitk::Label which is used as default exterior label
      * @return the exterior mitk::Label
      */
     mitk::Label *GetExteriorLabel();
 
     const mitk::Label *GetExteriorLabel() const;
 
   protected:
     mitkCloneMacro(Self);
 
       LabelSetImage();
     LabelSetImage(const LabelSetImage &other);
     ~LabelSetImage() override;
 
-    template <typename ImageType1, typename ImageType2>
-    void ChangeLayerProcessing(ImageType1 *source, ImageType2 *target);
-
     template <typename TPixel, unsigned int VImageDimension>
     void LayerContainerToImageProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer);
 
     template <typename TPixel, unsigned int VImageDimension>
     void ImageToLayerContainerProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer) const;
 
     template <typename ImageType>
     void CalculateCenterOfMassProcessing(ImageType *input, PixelType index, unsigned int layer);
 
     template <typename ImageType>
     void ClearBufferProcessing(ImageType *input);
 
     template <typename ImageType>
-    void EraseLabelProcessing(ImageType *input, PixelType index, unsigned int layer);
-
-    //  template < typename ImageType >
-    //  void ReorderLabelProcessing( ImageType* input, int index, int layer);
+    void EraseLabelProcessing(ImageType *input, PixelType index);
 
     template <typename ImageType>
     void MergeLabelProcessing(ImageType *input, PixelType pixelValue, PixelType index);
 
-    template <typename ImageType>
-    void ConcatenateProcessing(ImageType *input, mitk::LabelSetImage *other);
-
     template <typename ImageType>
     void MaskStampProcessing(ImageType *input, mitk::Image *mask, bool forceOverwrite);
 
     template <typename LabelSetImageType, typename ImageType>
     void InitializeByLabeledImageProcessing(LabelSetImageType *input, ImageType *other);
 
     std::vector<LabelSet::Pointer> m_LabelSetContainer;
     std::vector<Image::Pointer> m_LayerContainer;
 
     int m_ActiveLayer;
 
     bool m_activeLayerInvalid;
 
     mitk::Label::Pointer m_ExteriorLabel;
   };
 
   /**
   * @brief Equal A function comparing two label set images for beeing equal in meta- and imagedata
   *
   * @ingroup MITKTestingAPI
   *
   * Following aspects are tested for equality:
   *  - LabelSetImage members
   *  - working image data
   *  - layer image data
   *  - labels in label set
   *
   * @param rightHandSide An image to be compared
   * @param leftHandSide An image to be compared
   * @param eps Tolerance for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return true, if all subsequent comparisons are true, false otherwise
   */
   MITKMULTILABEL_EXPORT bool Equal(const mitk::LabelSetImage &leftHandSide,
                                    const mitk::LabelSetImage &rightHandSide,
                                    ScalarType eps,
                                    bool verbose);
 
+
+  /** temporery namespace that is used until the new class MultiLabelSegmentation is
+    introduced. It allows to already introduce/use some upcoming definitions, while
+    refactoring code.*/
+  namespace MultiLabelSegmentation
+  {
+    enum class MergeStyle
+    {
+      Replace, //The old label content of a lable value will be replaced by its new label content.
+               //Therefore pixels that are labeled might become unlabeled again.
+               //(This means that a lock of the value is also ignored).
+      Merge //The union of old and new label content will be generated.
+    };
+
+    enum class OverwriteStyle
+    {
+      RegardLocks, //Locked labels in the same spatial group will not be overwritten/changed.
+      IgnoreLocks //Label locks in the same spatial group will be ignored, so these labels might be changed.
+    };
+  }
+
+  /**Helper function that transfers pixels of the specified source label from source image to the destination image by using
+  a specified destination label. Function processes the whole image volume of the specified time step.
+  @remark in its current implementation the function only transfers contents of the active layer of the passed LabelSetImages.
+  @remark the function assumes that it is only called with source and destination image of same geometry.
+  @param sourceImage Pointer to the LabelSetImage which active layer should be used as source for the transfer.
+  @param destinationImage Pointer to the LabelSetImage which active layer should be used as destination for the transfer.
+  @param labelMapping Map that encodes the mappings of all label pixel transfers that should be done. First element is the
+  label in the source image. The second element is the label that transferred pixels should become in the destination image.
+  The order in which the labels will be transfered is the same order of elements in the labelMapping.
+  If you use a heterogeneous label mapping (e.g. (1,2); so changing the label while transfering), keep in mind that
+  for the MergeStyle and OverwriteStyle only the destination label (second element) is relevant (e.g. what should be
+  altered with MergeStyle Replace).
+  @param mergeStyle indicates how the transfer should be done (merge or replace). For more details see documentation of
+  MultiLabelSegmentation::MergeStyle.
+  @param overwriteStlye indicates if label locks in the destination image should be regarded or not. For more details see
+  documentation of MultiLabelSegmentation::OverwriteStyle.
+  @param timeStep indicate the time step that should be transferred.
+  @pre sourceImage and destinationImage must be valid
+  @pre sourceImage and destinationImage must contain the indicated timeStep
+  @pre sourceImage must contain all indicated sourceLabels in its active layer.
+  @pre destinationImage must contain all indicated destinationLabels in its active layer.*/
+  MITKMULTILABEL_EXPORT void TransferLabelContent(const LabelSetImage* sourceImage, LabelSetImage* destinationImage,
+    std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping = { {1,1} },
+    MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
+    MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks,
+    const TimeStepType timeStep = 0);
+
+  /**Helper function that transfers pixels of the specified source label from source image to the destination image by using
+  a specified destination label. Function processes the whole image volume of the specified time step.
+  @remark the function assumes that it is only called with source and destination image of same geometry.
+  @param sourceImage Pointer to the image that should be used as source for the transfer.
+  @param destinationImage Pointer to the image that should be used as destination for the transfer.
+  @param destinationLabelSet Pointer to the label set specifying labels and lock states in the destination image. Unkown pixel
+  values in the destinationImage will be assumed to be unlocked.
+  @param sourceBackground Value indicating the background in the source image.
+  @param destinationBackground Value indicating the background in the destination image.
+  @param destinationBackgroundLocked Value indicating the lock state of the background in the destination image.
+  @param labelMapping Map that encodes the mappings of all label pixel transfers that should be done. First element is the
+  label in the source image. The second element is the label that transferred pixels should become in the destination image.
+  The order in which the labels will be transfered is the same order of elements in the labelMapping.
+  If you use a heterogeneous label mapping (e.g. (1,2); so changing the label while transfering), keep in mind that
+  for the MergeStyle and OverwriteStyle only the destination label (second element) is relevant (e.g. what should be
+  altered with MergeStyle Replace).
+  @param mergeStyle indicates how the transfer should be done (merge or replace). For more details see documentation of
+  MultiLabelSegmentation::MergeStyle.
+  @param overwriteStlye indicates if label locks in the destination image should be regarded or not. For more details see
+  documentation of MultiLabelSegmentation::OverwriteStyle.
+  @param timeStep indicate the time step that should be transferred.
+  @pre sourceImage, destinationImage and destinationLabelSet must be valid
+  @pre sourceImage and destinationImage must contain the indicated timeStep
+  @pre destinationLabelSet must contain all indicated destinationLabels for mapping.*/
+  MITKMULTILABEL_EXPORT void TransferLabelContent(const Image* sourceImage, Image* destinationImage, const mitk::LabelSet* destinationLabelSet,
+    mitk::Label::PixelType sourceBackground = 0, mitk::Label::PixelType destinationBackground = 0, bool destinationBackgroundLocked = false,
+    std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping = { {1,1} },
+    MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
+    MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks,
+    const TimeStepType timeStep = 0);
 } // namespace mitk
 
 #endif // __mitkLabelSetImage_H_
diff --git a/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.cpp b/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.cpp
index beb6d792ce..9436894b13 100644
--- a/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.cpp
+++ b/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.cpp
@@ -1,649 +1,649 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkLabelSetImageVtkMapper2D.h"
 
 // MITK
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkDataNode.h>
 #include <mitkImageSliceSelector.h>
 #include <mitkImageStatisticsHolder.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkPixelType.h>
 #include <mitkPlaneClipping.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkProperties.h>
 #include <mitkResliceMethodProperty.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 
 // MITK Rendering
 #include "vtkMitkLevelWindowFilter.h"
 #include "vtkMitkThickSlicesFilter.h"
 #include "vtkNeverTranslucentTexture.h"
 
 // VTK
 #include <vtkCamera.h>
 #include <vtkCellArray.h>
 #include <vtkImageData.h>
 #include <vtkImageReslice.h>
 #include <vtkLookupTable.h>
 #include <vtkMatrix4x4.h>
 #include <vtkPlaneSource.h>
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
 #include <vtkTransform.h>
 //#include <vtkOpenGLTexture.h>
 
 // ITK
 #include <itkRGBAPixel.h>
 #include <mitkRenderingModeProperty.h>
 
 mitk::LabelSetImageVtkMapper2D::LabelSetImageVtkMapper2D()
 {
 }
 
 mitk::LabelSetImageVtkMapper2D::~LabelSetImageVtkMapper2D()
 {
 }
 
 vtkProp *mitk::LabelSetImageVtkMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   // return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Actors;
 }
 
 mitk::LabelSetImageVtkMapper2D::LocalStorage *mitk::LabelSetImageVtkMapper2D::GetLocalStorage(
   mitk::BaseRenderer *renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 void mitk::LabelSetImageVtkMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   mitk::DataNode *node = this->GetDataNode();
   auto *image = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
   assert(image && image->IsInitialized());
 
   // check if there is a valid worldGeometry
   const PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
   if ((worldGeometry == nullptr) || (!worldGeometry->IsValid()) || (!worldGeometry->HasReferenceGeometry()))
     return;
 
   image->Update();
 
   int numberOfLayers = image->GetNumberOfLayers();
   int activeLayer = image->GetActiveLayer();
 
   float opacity = 1.0f;
   node->GetOpacity(opacity, renderer, "opacity");
 
   if (numberOfLayers != localStorage->m_NumberOfLayers)
   {
     localStorage->m_NumberOfLayers = numberOfLayers;
     localStorage->m_ReslicedImageVector.clear();
     localStorage->m_ReslicerVector.clear();
     localStorage->m_LayerTextureVector.clear();
     localStorage->m_LevelWindowFilterVector.clear();
     localStorage->m_LayerMapperVector.clear();
     localStorage->m_LayerActorVector.clear();
 
     localStorage->m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
 
     for (int lidx = 0; lidx < numberOfLayers; ++lidx)
     {
       localStorage->m_ReslicedImageVector.push_back(vtkSmartPointer<vtkImageData>::New());
       localStorage->m_ReslicerVector.push_back(mitk::ExtractSliceFilter::New());
       localStorage->m_LayerTextureVector.push_back(vtkSmartPointer<vtkNeverTranslucentTexture>::New());
       localStorage->m_LevelWindowFilterVector.push_back(vtkSmartPointer<vtkMitkLevelWindowFilter>::New());
       localStorage->m_LayerMapperVector.push_back(vtkSmartPointer<vtkPolyDataMapper>::New());
       localStorage->m_LayerActorVector.push_back(vtkSmartPointer<vtkActor>::New());
 
       // do not repeat the texture (the image)
       localStorage->m_LayerTextureVector[lidx]->RepeatOff();
 
       // set corresponding mappers for the actors
       localStorage->m_LayerActorVector[lidx]->SetMapper(localStorage->m_LayerMapperVector[lidx]);
 
       localStorage->m_Actors->AddPart(localStorage->m_LayerActorVector[lidx]);
     }
 
     localStorage->m_Actors->AddPart(localStorage->m_OutlineShadowActor);
     localStorage->m_Actors->AddPart(localStorage->m_OutlineActor);
   }
 
   // early out if there is no intersection of the current rendering geometry
   // and the geometry of the image that is to be rendered.
   if (!RenderingGeometryIntersectsImage(worldGeometry, image->GetSlicedGeometry()))
   {
     // set image to nullptr, to clear the texture in 3D, because
     // the latest image is used there if the plane is out of the geometry
     // see bug-13275
     for (int lidx = 0; lidx < numberOfLayers; ++lidx)
     {
       localStorage->m_ReslicedImageVector[lidx] = nullptr;
       localStorage->m_LayerMapperVector[lidx]->SetInputData(localStorage->m_EmptyPolyData);
       localStorage->m_OutlineActor->SetVisibility(false);
       localStorage->m_OutlineShadowActor->SetVisibility(false);
     }
     return;
   }
 
   for (int lidx = 0; lidx < numberOfLayers; ++lidx)
   {
     mitk::Image *layerImage = nullptr;
 
     // set main input for ExtractSliceFilter
     if (lidx == activeLayer)
       layerImage = image;
     else
       layerImage = image->GetLayerImage(lidx);
 
     localStorage->m_ReslicerVector[lidx]->SetInput(layerImage);
     localStorage->m_ReslicerVector[lidx]->SetWorldGeometry(worldGeometry);
     localStorage->m_ReslicerVector[lidx]->SetTimeStep(this->GetTimestep());
 
     // set the transformation of the image to adapt reslice axis
     localStorage->m_ReslicerVector[lidx]->SetResliceTransformByGeometry(
       layerImage->GetTimeGeometry()->GetGeometryForTimeStep(this->GetTimestep()));
 
     // is the geometry of the slice based on the image image or the worldgeometry?
     bool inPlaneResampleExtentByGeometry = false;
     node->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
     localStorage->m_ReslicerVector[lidx]->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
     localStorage->m_ReslicerVector[lidx]->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
     localStorage->m_ReslicerVector[lidx]->SetVtkOutputRequest(true);
 
     // this is needed when thick mode was enabled before. These variables have to be reset to default values
     localStorage->m_ReslicerVector[lidx]->SetOutputDimensionality(2);
     localStorage->m_ReslicerVector[lidx]->SetOutputSpacingZDirection(1.0);
     localStorage->m_ReslicerVector[lidx]->SetOutputExtentZDirection(0, 0);
 
     // Bounds information for reslicing (only required if reference geometry is present)
     // this used for generating a vtkPLaneSource with the right size
     double sliceBounds[6];
     sliceBounds[0] = 0.0;
     sliceBounds[1] = 0.0;
     sliceBounds[2] = 0.0;
     sliceBounds[3] = 0.0;
     sliceBounds[4] = 0.0;
     sliceBounds[5] = 0.0;
 
     localStorage->m_ReslicerVector[lidx]->GetClippedPlaneBounds(sliceBounds);
 
     // setup the textured plane
     this->GeneratePlane(renderer, sliceBounds);
 
     // get the spacing of the slice
     localStorage->m_mmPerPixel = localStorage->m_ReslicerVector[lidx]->GetOutputSpacing();
     localStorage->m_ReslicerVector[lidx]->Modified();
     // start the pipeline with updating the largest possible, needed if the geometry of the image has changed
     localStorage->m_ReslicerVector[lidx]->UpdateLargestPossibleRegion();
     localStorage->m_ReslicedImageVector[lidx] = localStorage->m_ReslicerVector[lidx]->GetVtkOutput();
 
     const auto *planeGeometry = dynamic_cast<const PlaneGeometry *>(worldGeometry);
 
     double textureClippingBounds[6];
     for (auto &textureClippingBound : textureClippingBounds)
     {
       textureClippingBound = 0.0;
     }
 
     // Calculate the actual bounds of the transformed plane clipped by the
     // dataset bounding box; this is required for drawing the texture at the
     // correct position during 3D mapping.
     mitk::PlaneClipping::CalculateClippedPlaneBounds(layerImage->GetGeometry(), planeGeometry, textureClippingBounds);
 
     textureClippingBounds[0] = static_cast<int>(textureClippingBounds[0] / localStorage->m_mmPerPixel[0] + 0.5);
     textureClippingBounds[1] = static_cast<int>(textureClippingBounds[1] / localStorage->m_mmPerPixel[0] + 0.5);
     textureClippingBounds[2] = static_cast<int>(textureClippingBounds[2] / localStorage->m_mmPerPixel[1] + 0.5);
     textureClippingBounds[3] = static_cast<int>(textureClippingBounds[3] / localStorage->m_mmPerPixel[1] + 0.5);
 
     // clipping bounds for cutting the imageLayer
     localStorage->m_LevelWindowFilterVector[lidx]->SetClippingBounds(textureClippingBounds);
 
     localStorage->m_LevelWindowFilterVector[lidx]->SetLookupTable(
       image->GetLabelSet(lidx)->GetLookupTable()->GetVtkLookupTable());
 
     // do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
     localStorage->m_LayerTextureVector[lidx]->SetColorModeToDirectScalars();
 
     // connect the imageLayer with the levelwindow filter
     localStorage->m_LevelWindowFilterVector[lidx]->SetInputData(localStorage->m_ReslicedImageVector[lidx]);
     // connect the texture with the output of the levelwindow filter
 
     // check for texture interpolation property
     bool textureInterpolation = false;
     node->GetBoolProperty("texture interpolation", textureInterpolation, renderer);
 
     // set the interpolation modus according to the property
     localStorage->m_LayerTextureVector[lidx]->SetInterpolate(textureInterpolation);
 
     localStorage->m_LayerTextureVector[lidx]->SetInputConnection(
       localStorage->m_LevelWindowFilterVector[lidx]->GetOutputPort());
 
     this->TransformActor(renderer);
 
     // set the plane as input for the mapper
     localStorage->m_LayerMapperVector[lidx]->SetInputConnection(localStorage->m_Plane->GetOutputPort());
 
     // set the texture for the actor
     localStorage->m_LayerActorVector[lidx]->SetTexture(localStorage->m_LayerTextureVector[lidx]);
     localStorage->m_LayerActorVector[lidx]->GetProperty()->SetOpacity(opacity);
   }
 
   mitk::Label* activeLabel = image->GetActiveLabel(activeLayer);
   if (nullptr != activeLabel)
   {
     bool contourActive = false;
     node->GetBoolProperty("labelset.contour.active", contourActive, renderer);
     if (contourActive && activeLabel->GetVisible()) //contour rendering
     {
       //generate contours/outlines
       localStorage->m_OutlinePolyData =
         this->CreateOutlinePolyData(renderer, localStorage->m_ReslicedImageVector[activeLayer], activeLabel->GetValue());
       localStorage->m_OutlineActor->SetVisibility(true);
       localStorage->m_OutlineShadowActor->SetVisibility(true);
       const mitk::Color& color = activeLabel->GetColor();
       localStorage->m_OutlineActor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
       localStorage->m_OutlineShadowActor->GetProperty()->SetColor(0, 0, 0);
 
       float contourWidth(2.0);
       node->GetFloatProperty("labelset.contour.width", contourWidth, renderer);
       localStorage->m_OutlineActor->GetProperty()->SetLineWidth(contourWidth);
       localStorage->m_OutlineShadowActor->GetProperty()->SetLineWidth(contourWidth * 1.5);
 
       localStorage->m_OutlineActor->GetProperty()->SetOpacity(opacity);
       localStorage->m_OutlineShadowActor->GetProperty()->SetOpacity(opacity);
 
       localStorage->m_OutlineMapper->SetInputData(localStorage->m_OutlinePolyData);
       return;
     }
   }
   localStorage->m_OutlineActor->SetVisibility(false);
   localStorage->m_OutlineShadowActor->SetVisibility(false);
 }
 
 bool mitk::LabelSetImageVtkMapper2D::RenderingGeometryIntersectsImage(const PlaneGeometry *renderingGeometry,
                                                                       SlicedGeometry3D *imageGeometry)
 {
   // if either one of the two geometries is nullptr we return true
   // for safety reasons
   if (renderingGeometry == nullptr || imageGeometry == nullptr)
     return true;
 
   // get the distance for the first cornerpoint
   ScalarType initialDistance = renderingGeometry->SignedDistance(imageGeometry->GetCornerPoint(0));
   for (int i = 1; i < 8; i++)
   {
     mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint(i);
 
     // get the distance to the other cornerpoints
     ScalarType distance = renderingGeometry->SignedDistance(cornerPoint);
 
     // if it has not the same signing as the distance of the first point
     if (initialDistance * distance < 0)
     {
       // we have an intersection and return true
       return true;
     }
   }
 
   // all distances have the same sign, no intersection and we return false
   return false;
 }
 
 vtkSmartPointer<vtkPolyData> mitk::LabelSetImageVtkMapper2D::CreateOutlinePolyData(mitk::BaseRenderer *renderer,
                                                                                    vtkImageData *image,
                                                                                    int pixelValue)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
 
   // get the min and max index values of each direction
   int *extent = image->GetExtent();
   int xMin = extent[0];
   int xMax = extent[1];
   int yMin = extent[2];
   int yMax = extent[3];
 
   int *dims = image->GetDimensions(); // dimensions of the image
   int line = dims[0];                 // how many pixels per line?
   int x = xMin;                       // pixel index x
   int y = yMin;                       // pixel index y
 
   // get the depth for each contour
   float depth = this->CalculateLayerDepth(renderer);
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();      // the points to draw
   vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New(); // the lines to connect the points
 
   // We take the pointer to the first pixel of the image
   auto *currentPixel = static_cast<mitk::Label::PixelType *>(image->GetScalarPointer());
 
   while (y <= yMax)
   {
     // if the current pixel value is set to something
     if ((currentPixel) && (*currentPixel == pixelValue))
     {
       // check in which direction a line is necessary
       // a line is added if the neighbor of the current pixel has the value 0
       // and if the pixel is located at the edge of the image
 
       // if   vvvvv  not the first line vvvvv
       if (y > yMin && *(currentPixel - line) != pixelValue)
       { // x direction - bottom edge of the pixel
         // add the 2 points
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         // add the line between both points
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  not the last line vvvvv
       if (y < yMax && *(currentPixel + line) != pixelValue)
       { // x direction - top edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  not the first pixel vvvvv
       if ((x > xMin || y > yMin) && *(currentPixel - 1) != pixelValue)
       { // y direction - left edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  not the last pixel vvvvv
       if ((y < yMax || (x < xMax)) && *(currentPixel + 1) != pixelValue)
       { // y direction - right edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       /*  now consider pixels at the edge of the image  */
 
       // if   vvvvv  left edge of image vvvvv
       if (x == xMin)
       { // draw left edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  right edge of image vvvvv
       if (x == xMax)
       { // draw right edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  bottom edge of image vvvvv
       if (y == yMin)
       { // draw bottom edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  top edge of image vvvvv
       if (y == yMax)
       { // draw top edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
     } // end if currentpixel is set
 
     x++;
 
     if (x > xMax)
     { // reached end of line
       x = xMin;
       y++;
     }
 
     // Increase the pointer-position to the next pixel.
     // This is safe, as the while-loop and the x-reset logic above makes
     // sure we do not exceed the bounds of the image
     currentPixel++;
   } // end of while
 
   // Create a polydata to store everything in
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   // Add the points to the dataset
   polyData->SetPoints(points);
   // Add the lines to the dataset
   polyData->SetLines(lines);
   return polyData;
 }
 
 void mitk::LabelSetImageVtkMapper2D::ApplyColor(mitk::BaseRenderer *renderer, const mitk::Color &color)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
   localStorage->m_OutlineActor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
   localStorage->m_OutlineShadowActor->GetProperty()->SetColor(0, 0, 0);
 }
 
 void mitk::LabelSetImageVtkMapper2D::ApplyOpacity(mitk::BaseRenderer *renderer, int layer)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
   float opacity = 1.0f;
   this->GetDataNode()->GetOpacity(opacity, renderer, "opacity");
   localStorage->m_LayerActorVector[layer]->GetProperty()->SetOpacity(opacity);
   localStorage->m_OutlineActor->GetProperty()->SetOpacity(opacity);
   localStorage->m_OutlineShadowActor->GetProperty()->SetOpacity(opacity);
 }
 
 void mitk::LabelSetImageVtkMapper2D::ApplyLookuptable(mitk::BaseRenderer *renderer, int layer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   auto *input = dynamic_cast<mitk::LabelSetImage *>(this->GetDataNode()->GetData());
   localStorage->m_LevelWindowFilterVector[layer]->SetLookupTable(
     input->GetLabelSet(layer)->GetLookupTable()->GetVtkLookupTable());
 }
 
 void mitk::LabelSetImageVtkMapper2D::Update(mitk::BaseRenderer *renderer)
 {
   bool visible = true;
   const DataNode *node = this->GetDataNode();
   node->GetVisibility(visible, renderer, "visible");
 
   if (!visible)
     return;
 
   auto *image = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
 
   if (image == nullptr || image->IsInitialized() == false)
     return;
 
   // Calculate time step of the image data for the specified renderer (integer value)
   this->CalculateTimeStep(renderer);
 
   // Check if time step is valid
   const TimeGeometry *dataTimeGeometry = image->GetTimeGeometry();
   if ((dataTimeGeometry == nullptr) || (dataTimeGeometry->CountTimeSteps() == 0) ||
       (!dataTimeGeometry->IsValidTimeStep(this->GetTimestep())))
   {
     return;
   }
 
   image->UpdateOutputInformation();
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   // check if something important has changed and we need to re-render
 
   if ((localStorage->m_LastDataUpdateTime < image->GetMTime()) ||
       (localStorage->m_LastDataUpdateTime < image->GetPipelineMTime()) ||
       (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) ||
       (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()))
   {
     this->GenerateDataForRenderer(renderer);
     localStorage->m_LastDataUpdateTime.Modified();
   }
   else if ((localStorage->m_LastPropertyUpdateTime < node->GetPropertyList()->GetMTime()) ||
            (localStorage->m_LastPropertyUpdateTime < node->GetPropertyList(renderer)->GetMTime()) ||
            (localStorage->m_LastPropertyUpdateTime < image->GetPropertyList()->GetMTime()))
   {
     this->GenerateDataForRenderer(renderer);
     localStorage->m_LastPropertyUpdateTime.Modified();
   }
 }
 
 // set the two points defining the textured plane according to the dimension and spacing
 void mitk::LabelSetImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer *renderer, double planeBounds[6])
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   float depth = this->CalculateLayerDepth(renderer);
   // Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
   // plane size in crosshair rotation and swivel mode.
   localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
   // These two points define the axes of the plane in combination with the origin.
   // Point 1 is the x-axis and point 2 the y-axis.
-  // Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
+  // Each plane is transformed according to the view (axial, coronal and sagittal) afterwards.
   localStorage->m_Plane->SetPoint1(planeBounds[1], planeBounds[2], depth); // P1: (xMax, yMin, depth)
   localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); // P2: (xMin, yMax, depth)
 }
 
 float mitk::LabelSetImageVtkMapper2D::CalculateLayerDepth(mitk::BaseRenderer *renderer)
 {
   // get the clipping range to check how deep into z direction we can render images
   double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
 
   // Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
   float depth = -maxRange * 0.01; // divide by 100
   int layer = 0;
   GetDataNode()->GetIntProperty("layer", layer, renderer);
   // add the layer property for each image to render images with a higher layer on top of the others
   depth += layer * 10; //*10: keep some room for each image (e.g. for ODFs in between)
   if (depth > 0.0f)
   {
     depth = 0.0f;
     MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
   }
   return depth;
 }
 
 void mitk::LabelSetImageVtkMapper2D::TransformActor(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
-  // get the transformation matrix of the reslicer in order to render the slice as axial, coronal or saggital
+  // get the transformation matrix of the reslicer in order to render the slice as axial, coronal or sagittal
   vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
   vtkSmartPointer<vtkMatrix4x4> matrix = localStorage->m_ReslicerVector[0]->GetResliceAxes(); // same for all layers
   trans->SetMatrix(matrix);
 
   for (int lidx = 0; lidx < localStorage->m_NumberOfLayers; ++lidx)
   {
-    // transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or saggital)
+    // transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or sagittal)
     localStorage->m_LayerActorVector[lidx]->SetUserTransform(trans);
     // transform the origin to center based coordinates, because MITK is center based.
     localStorage->m_LayerActorVector[lidx]->SetPosition(
       -0.5 * localStorage->m_mmPerPixel[0], -0.5 * localStorage->m_mmPerPixel[1], 0.0);
   }
   // same for outline actor
   localStorage->m_OutlineActor->SetUserTransform(trans);
   localStorage->m_OutlineActor->SetPosition(
     -0.5 * localStorage->m_mmPerPixel[0], -0.5 * localStorage->m_mmPerPixel[1], 0.0);
   // same for outline shadow actor
   localStorage->m_OutlineShadowActor->SetUserTransform(trans);
   localStorage->m_OutlineShadowActor->SetPosition(
     -0.5 * localStorage->m_mmPerPixel[0], -0.5 * localStorage->m_mmPerPixel[1], 0.0);
 }
 
 void mitk::LabelSetImageVtkMapper2D::SetDefaultProperties(mitk::DataNode *node,
                                                           mitk::BaseRenderer *renderer,
                                                           bool overwrite)
 {
   // add/replace the following properties
   node->SetProperty("opacity", FloatProperty::New(1.0f), renderer);
   node->SetProperty("binary", BoolProperty::New(false), renderer);
 
   mitk::RenderingModeProperty::Pointer renderingModeProperty =
     mitk::RenderingModeProperty::New(RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR);
   node->SetProperty("Image Rendering.Mode", renderingModeProperty, renderer);
 
   mitk::LevelWindow levelwindow(32767.5, 65535);
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New(levelwindow);
 
   levWinProp->SetLevelWindow(levelwindow);
   node->SetProperty("levelwindow", levWinProp, renderer);
 
   node->SetProperty("labelset.contour.active", BoolProperty::New(true), renderer);
   node->SetProperty("labelset.contour.width", FloatProperty::New(2.0), renderer);
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 mitk::LabelSetImageVtkMapper2D::LocalStorage::~LocalStorage()
 {
 }
 
 mitk::LabelSetImageVtkMapper2D::LocalStorage::LocalStorage()
 {
   // Do as much actions as possible in here to avoid double executions.
   m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
   m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
   m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
   m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_OutlineActor = vtkSmartPointer<vtkActor>::New();
   m_OutlineMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_OutlineShadowActor = vtkSmartPointer<vtkActor>::New();
 
   m_NumberOfLayers = 0;
   m_mmPerPixel = nullptr;
 
   m_OutlineActor->SetMapper(m_OutlineMapper);
   m_OutlineShadowActor->SetMapper(m_OutlineMapper);
 
   m_OutlineActor->SetVisibility(false);
   m_OutlineShadowActor->SetVisibility(false);
 }
diff --git a/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.h b/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.h
index 884388bfa9..893971810f 100644
--- a/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.h
+++ b/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.h
@@ -1,241 +1,241 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef __mitkLabelSetImageVtkMapper2D_H_
 #define __mitkLabelSetImageVtkMapper2D_H_
 
 // MITK
 #include "MitkMultilabelExports.h"
 #include "mitkCommon.h"
 
 // MITK Rendering
 #include "mitkBaseRenderer.h"
 #include "mitkExtractSliceFilter.h"
 #include "mitkLabelSetImage.h"
 #include "mitkVtkMapper.h"
 
 // VTK
 #include <vtkSmartPointer.h>
 
 class vtkActor;
 class vtkPolyDataMapper;
 class vtkPlaneSource;
 class vtkImageData;
 class vtkLookupTable;
 class vtkImageReslice;
 class vtkPoints;
 class vtkMitkThickSlicesFilter;
 class vtkPolyData;
 class vtkMitkLevelWindowFilter;
 class vtkNeverTranslucentTexture;
 
 namespace mitk
 {
 
   /** \brief Mapper to resample and display 2D slices of a 3D labelset image.
    *
    * Properties that can be set for labelset images and influence this mapper are:
    *
    *   - \b "labelset.contour.active": (BoolProperty) whether to show only the active label as a contour or not
    *   - \b "labelset.contour.width": (FloatProperty) line width of the contour
 
    * The default properties are:
 
    *   - \b "labelset.contour.active", mitk::BoolProperty::New( true ), renderer, overwrite )
    *   - \b "labelset.contour.width", mitk::FloatProperty::New( 2.0 ), renderer, overwrite )
 
    * \ingroup Mapper
    */
   class MITKMULTILABEL_EXPORT LabelSetImageVtkMapper2D : public VtkMapper
   {
   public:
     /** Standard class typedefs. */
     mitkClassMacro(LabelSetImageVtkMapper2D, VtkMapper);
 
     /** Method for creation through the object factory. */
     itkNewMacro(Self);
 
     /** \brief Get the Image to map */
     const mitk::Image *GetInput(void);
 
     /** \brief Checks whether this mapper needs to update itself and generate
      * data. */
     void Update(mitk::BaseRenderer *renderer) override;
 
     //### methods of MITK-VTK rendering pipeline
     vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;
     //### end of methods of MITK-VTK rendering pipeline
 
     /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
     /**
-       * To render transversal, coronal, and sagittal, the mapper is called three times.
+       * To render axial, coronal, and sagittal, the mapper is called three times.
        * For performance reasons, the corresponding data for each view is saved in the
        * internal helper class LocalStorage. This allows rendering n views with just
        * 1 mitkMapper using n vtkMapper.
        * */
     class MITKMULTILABEL_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
     {
     public:
       vtkSmartPointer<vtkPropAssembly> m_Actors;
 
       std::vector<vtkSmartPointer<vtkActor>> m_LayerActorVector;
       std::vector<vtkSmartPointer<vtkPolyDataMapper>> m_LayerMapperVector;
       std::vector<vtkSmartPointer<vtkImageData>> m_ReslicedImageVector;
       std::vector<vtkSmartPointer<vtkNeverTranslucentTexture>> m_LayerTextureVector;
 
       vtkSmartPointer<vtkPolyData> m_EmptyPolyData;
       vtkSmartPointer<vtkPlaneSource> m_Plane;
 
       std::vector<mitk::ExtractSliceFilter::Pointer> m_ReslicerVector;
 
       vtkSmartPointer<vtkPolyData> m_OutlinePolyData;
       /** \brief An actor for the outline */
       vtkSmartPointer<vtkActor> m_OutlineActor;
       /** \brief An actor for the outline shadow*/
       vtkSmartPointer<vtkActor> m_OutlineShadowActor;
       /** \brief A mapper for the outline */
       vtkSmartPointer<vtkPolyDataMapper> m_OutlineMapper;
 
       /** \brief Timestamp of last update of stored data. */
       itk::TimeStamp m_LastDataUpdateTime;
 
       /** \brief Timestamp of last update of a property. */
       itk::TimeStamp m_LastPropertyUpdateTime;
 
       /** \brief mmPerPixel relation between pixel and mm. (World spacing).*/
       mitk::ScalarType *m_mmPerPixel;
 
       int m_NumberOfLayers;
 
       /** \brief This filter is used to apply the level window to Grayvalue and RBG(A) images. */
       // vtkSmartPointer<vtkMitkLevelWindowFilter> m_LevelWindowFilter;
       std::vector<vtkSmartPointer<vtkMitkLevelWindowFilter>> m_LevelWindowFilterVector;
 
       /** \brief Default constructor of the local storage. */
       LocalStorage();
       /** \brief Default deconstructor of the local storage. */
       ~LocalStorage() override;
     };
 
     /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
     mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
     /** \brief Get the LocalStorage corresponding to the current renderer. */
     LocalStorage *GetLocalStorage(mitk::BaseRenderer *renderer);
 
     /** \brief Set the default properties for general image rendering. */
     static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
 
     /** \brief This method switches between different rendering modes (e.g. use a lookup table or a transfer function).
      * Detailed documentation about the modes can be found here: \link mitk::RenderingModeProperty \endlink
      */
     void ApplyRenderingMode(mitk::BaseRenderer *renderer);
 
   protected:
     /** \brief Transforms the actor to the actual position in 3D.
       *   \param renderer The current renderer corresponding to the render window.
       */
     void TransformActor(mitk::BaseRenderer *renderer);
 
     /** \brief Generates a plane according to the size of the resliced image in milimeters.
       *
       * In VTK a vtkPlaneSource is defined through three points. The origin and two
       * points defining the axes of the plane (see VTK documentation). The origin is
       * set to (xMin; yMin; Z), where xMin and yMin are the minimal bounds of the
       * resliced image in space. Z is relevant for blending and the layer property.
       * The center of the plane (C) is also the center of the view plane (cf. the image above).
       *
       * \note For the standard MITK view with three 2D render windows showing three
       * different slices, three such planes are generated. All these planes are generated
       * in the XY-plane (even if they depict a YZ-slice of the volume).
       *
       */
     void GeneratePlane(mitk::BaseRenderer *renderer, double planeBounds[6]);
 
     /** \brief Generates a vtkPolyData object containing the outline of a given binary slice.
         \param renderer Pointer to the renderer containing the needed information
         \param image
         \param pixelValue
         \note This code is based on code from the iil library.
         */
     vtkSmartPointer<vtkPolyData> CreateOutlinePolyData(mitk::BaseRenderer *renderer,
                                                        vtkImageData *image,
                                                        int pixelValue = 1);
 
     /** Default constructor */
     LabelSetImageVtkMapper2D();
     /** Default deconstructor */
     ~LabelSetImageVtkMapper2D() override;
 
     /** \brief Does the actual resampling, without rendering the image yet.
       * All the data is generated inside this method. The vtkProp (or Actor)
       * is filled with content (i.e. the resliced image).
       *
       * After generation, a 4x4 transformation matrix(t) of the current slice is obtained
       * from the vtkResliceImage object via GetReslicesAxis(). This matrix is
       * applied to each textured plane (actor->SetUserTransform(t)) to transform everything
       * to the actual 3D position (cf. the following image).
       *
       * \image html cameraPositioning3D.png
       *
       */
     void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
 
     /** \brief This method uses the vtkCamera clipping range and the layer property
       * to calcualte the depth of the object (e.g. image or contour). The depth is used
       * to keep the correct order for the final VTK rendering.*/
     float CalculateLayerDepth(mitk::BaseRenderer *renderer);
 
     /** \brief This method applies (or modifies) the lookuptable for all types of images.
      * \warning To use the lookup table, the property 'Lookup Table' must be set and a 'Image Rendering.Mode'
      * which uses the lookup table must be set.
   */
     void ApplyLookuptable(mitk::BaseRenderer *renderer, int layer);
 
     /** \brief This method applies a color transfer function.
      * Internally, a vtkColorTransferFunction is used. This is usefull for coloring continous
      * images (e.g. float)
      * \warning To use the color transfer function, the property 'Image Rendering.Transfer Function' must be set and a
      * 'Image Rendering.Mode' which uses the color transfer function must be set.
   */
     void ApplyColorTransferFunction(mitk::BaseRenderer *renderer);
 
     /**
      * @brief ApplyLevelWindow Apply the level window for the given renderer.
      * \warning To use the level window, the property 'LevelWindow' must be set and a 'Image Rendering.Mode' which uses
      * the level window must be set.
      * @param renderer Level window for which renderer?
      */
     void ApplyLevelWindow(mitk::BaseRenderer *renderer);
 
     /** \brief Set the color of the image/polydata */
     void ApplyColor(mitk::BaseRenderer *renderer, const mitk::Color &color);
 
     /** \brief Set the opacity of the actor. */
     void ApplyOpacity(mitk::BaseRenderer *renderer, int layer);
 
     /**
       * \brief Calculates whether the given rendering geometry intersects the
       * given SlicedGeometry3D.
       *
       * This method checks if the given Geometry2D intersects the given
       * SlicedGeometry3D. It calculates the distance of the Geometry2D to all
       * 8 cornerpoints of the SlicedGeometry3D. If all distances have the same
       * sign (all positive or all negative) there is no intersection.
       * If the distances have different sign, there is an intersection.
       **/
     bool RenderingGeometryIntersectsImage(const PlaneGeometry *renderingGeometry, SlicedGeometry3D *imageGeometry);
   };
 
 } // namespace mitk
 
 #endif // __mitkLabelSetImageVtkMapper2D_H_
diff --git a/Modules/OpenCVVideoSupport/mitkUndistortCameraImage.h b/Modules/OpenCVVideoSupport/mitkUndistortCameraImage.h
index b2ffc3aa30..1f9509b827 100644
--- a/Modules/OpenCVVideoSupport/mitkUndistortCameraImage.h
+++ b/Modules/OpenCVVideoSupport/mitkUndistortCameraImage.h
@@ -1,126 +1,125 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef __mitkUndistortCameraImage_h
 #define __mitkUndistortCameraImage_h
 
 #include "mitkCommon.h"
 #include <MitkOpenCVVideoSupportExports.h>
 #include "itkObject.h"
 
 #include "mitkPoint.h"
 
 #include "opencv2/core.hpp"
 #include "opencv2/imgproc.hpp"
 
 /*!
 \brief UndistortCameraImage
 
 This class is used to undistort camera images. Before any undistortion the class has to be initialized using the functions:
 SetFocalLength(),SetPrinzipalPoint() and SetCameraDistortion().
 After this you can either use UndistortPixel() to undistort a single pixel's coordinates or UndistortImage() to undistort an
 OpenCV image.
 
 A faster version of UndistortImage() is UndistortImageFast(), however, it has to be initialized once with SetUndistortImageFastInfo()
 instead of the Set... methods before use.
 
-\sa QmitkFunctionality
 \ingroup Functionalities
 */
 
 namespace mitk
 {
 
 class MITKOPENCVVIDEOSUPPORT_EXPORT UndistortCameraImage : public itk::Object
 {
   public:
 
     mitkClassMacroItkParent(UndistortCameraImage,itk::Object);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     /// Initialization ///
     /*
     * Set the camera's intrinsic focal length
     */
     void SetFocalLength(float fc_x, float fc_y)
     {
       m_fcX = fc_x; m_fcY = fc_y;
     }
     /*
     * Set the camera's intrinsic principal point
     */
     void SetPrincipalPoint(float cc_x, float cc_y)
     {
       m_ccX = cc_x; m_ccY = cc_y;
     }
     /*
     * Set the camera's intrinsic distortion parameters
     */
     void SetCameraDistortion(float kc1, float kc2, float kc3, float kc4)
     {
       m_distortionMatrixData[0] = kc1; m_distortionMatrixData[1] = kc2;
       m_distortionMatrixData[2] = kc3; m_distortionMatrixData[3] = kc4;
     }
     /*
     * Pre-Calculates matrices for the later use of UndistortImageFast()
     */
     void InitRemapUndistortion(int sizeX, int sizeY);
 
     /// USAGE ///
     /*
     * Undistort a single pixel, returns undistorted pixel
     */
     mitk::Point2D UndistortPixel(const mitk::Point2D& src);
     /*
     * Complete undistortion of an OpenCV image, including all calculations
     */
     void UndistortImage(IplImage* src, IplImage* dst);
 
 
     /*
     * Complete undistortion of an OpenCV image, using pre-calculated matrices from SetUndistortImageFastInfo()
     * The use of only a source parameter will cause the source to be overwritten.
     * NOTE: Using the Fast undistortion methods does not require a initialization via the Set... methods.
     */
     void UndistortImageFast( IplImage * src, IplImage* dst = nullptr );
     void SetUndistortImageFastInfo(float in_dF1, float in_dF2,
                                    float in_dPrincipalX, float in_dPrincipalY,
                                    float in_Dist[4], float ImageSizeX, float ImageSizeY);
 
     UndistortCameraImage();
     ~UndistortCameraImage() override;
 
   protected:
 
     // principal point and focal length parameters
     float m_ccX, m_ccY, m_fcX, m_fcY;
     // undistortion parameters
     float m_distortionMatrixData[4];
     // intrinsic camera parameters
     float m_intrinsicMatrixData[9];
     // precalculated matrices for fast image undistortion with UndistortImageFast()
     CvMat * m_mapX, * m_mapY;
     // intrinsic and undistortion camera matrices
     CvMat m_intrinsicMatrix, m_distortionMatrix;
     // temp image
     IplImage * m_tempImage;
 
 
 
     CvMat *m_DistortionCoeffs;
     CvMat *m_CameraMatrix;
 };
 
 }
 
 #endif
diff --git a/Modules/Pharmacokinetics/src/Models/mitkDescriptivePharmacokineticBrixModel.cpp b/Modules/Pharmacokinetics/src/Models/mitkDescriptivePharmacokineticBrixModel.cpp
index 6e43f11d5b..438f0353c3 100644
--- a/Modules/Pharmacokinetics/src/Models/mitkDescriptivePharmacokineticBrixModel.cpp
+++ b/Modules/Pharmacokinetics/src/Models/mitkDescriptivePharmacokineticBrixModel.cpp
@@ -1,257 +1,263 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkDescriptivePharmacokineticBrixModel.h"
 
 const std::string mitk::DescriptivePharmacokineticBrixModel::MODEL_DISPLAY_NAME =
   "Descriptive Pharmacokinetic Brix Model";
 
 const std::string mitk::DescriptivePharmacokineticBrixModel::NAME_PARAMETER_A = "A";
 const std::string mitk::DescriptivePharmacokineticBrixModel::NAME_PARAMETER_kep = "kep";
 const std::string mitk::DescriptivePharmacokineticBrixModel::NAME_PARAMETER_kel = "kel";
 //tlag in minutes
 const std::string mitk::DescriptivePharmacokineticBrixModel::NAME_PARAMETER_tlag = "tlag";
 
 const std::string mitk::DescriptivePharmacokineticBrixModel::UNIT_PARAMETER_A = "a.u.";
 const std::string mitk::DescriptivePharmacokineticBrixModel::UNIT_PARAMETER_kep = "1/min";
 const std::string mitk::DescriptivePharmacokineticBrixModel::UNIT_PARAMETER_kel = "1/min";
 //tlag in minutes
 const std::string mitk::DescriptivePharmacokineticBrixModel::UNIT_PARAMETER_tlag = "min";
 
 const std::string mitk::DescriptivePharmacokineticBrixModel::NAME_STATIC_PARAMETER_Tau = "Tau";
 const std::string mitk::DescriptivePharmacokineticBrixModel::NAME_STATIC_PARAMETER_S0 = "S0";
 
 const std::string mitk::DescriptivePharmacokineticBrixModel::UNIT_STATIC_PARAMETER_Tau = "min";
 const std::string mitk::DescriptivePharmacokineticBrixModel::UNIT_STATIC_PARAMETER_S0 = "I";
 
 const unsigned int mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_A = 0;
 const unsigned int mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_kep = 1;
 const unsigned int mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_kel = 2;
 const unsigned int mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_tlag = 3;
 
 const unsigned int mitk::DescriptivePharmacokineticBrixModel::NUMBER_OF_PARAMETERS = 4;
 
 std::string mitk::DescriptivePharmacokineticBrixModel::GetModelDisplayName() const
 {
   return MODEL_DISPLAY_NAME;
 };
 
 std::string mitk::DescriptivePharmacokineticBrixModel::GetModelType() const
 {
   return "Perfusion.MR";
 };
 
 std::string mitk::DescriptivePharmacokineticBrixModel::GetXAxisName() const
 {
   return "Time";
 };
 
 std::string mitk::DescriptivePharmacokineticBrixModel::GetXAxisUnit() const
 {
   return "s";
 }
 
 std::string mitk::DescriptivePharmacokineticBrixModel::GetYAxisName() const
 {
   return "";
 };
 
 std::string mitk::DescriptivePharmacokineticBrixModel::GetYAxisUnit() const
 {
   return "";
 }
 
 mitk::DescriptivePharmacokineticBrixModel::DescriptivePharmacokineticBrixModel(): m_Tau(0), m_S0(1)
 {
 
 }
 
 mitk::DescriptivePharmacokineticBrixModel::~DescriptivePharmacokineticBrixModel()
 {
 
 }
 
 mitk::DescriptivePharmacokineticBrixModel::ParameterNamesType
 mitk::DescriptivePharmacokineticBrixModel::GetParameterNames() const
 {
   ParameterNamesType result;
 
   result.push_back(NAME_PARAMETER_A);
   result.push_back(NAME_PARAMETER_kep);
   result.push_back(NAME_PARAMETER_kel);
   result.push_back(NAME_PARAMETER_tlag);
 
   return result;
 }
 
 mitk::DescriptivePharmacokineticBrixModel::ParametersSizeType
 mitk::DescriptivePharmacokineticBrixModel::GetNumberOfParameters() const
 {
   return NUMBER_OF_PARAMETERS;
 }
 
 mitk::DescriptivePharmacokineticBrixModel::ParamterUnitMapType
 mitk::DescriptivePharmacokineticBrixModel::GetParameterUnits() const
 {
   ParamterUnitMapType result;
 
   result.insert(std::make_pair(NAME_PARAMETER_A, UNIT_PARAMETER_A));
   result.insert(std::make_pair(NAME_PARAMETER_kep, UNIT_PARAMETER_kep));
   result.insert(std::make_pair(NAME_PARAMETER_kel, UNIT_PARAMETER_kel));
   result.insert(std::make_pair(NAME_PARAMETER_tlag, UNIT_PARAMETER_tlag));
 
   return result;
 };
 
 mitk::DescriptivePharmacokineticBrixModel::ParameterNamesType
 mitk::DescriptivePharmacokineticBrixModel::GetStaticParameterNames() const
 {
   ParameterNamesType result;
 
   result.push_back(NAME_STATIC_PARAMETER_Tau);
   result.push_back(NAME_STATIC_PARAMETER_S0);
 
   return result;
 }
 
 mitk::DescriptivePharmacokineticBrixModel::ParamterUnitMapType
 mitk::DescriptivePharmacokineticBrixModel::GetStaticParameterUnits() const
 {
   ParamterUnitMapType result;
 
   result.insert(std::make_pair(NAME_STATIC_PARAMETER_Tau, UNIT_STATIC_PARAMETER_Tau));
   result.insert(std::make_pair(NAME_STATIC_PARAMETER_S0, UNIT_STATIC_PARAMETER_S0));
 
   return result;
 };
 
 mitk::DescriptivePharmacokineticBrixModel::ParametersSizeType
 mitk::DescriptivePharmacokineticBrixModel::GetNumberOfStaticParameters() const
 {
-  return 1;
+  return 2;
 }
 
 
 mitk::DescriptivePharmacokineticBrixModel::ModelResultType
 mitk::DescriptivePharmacokineticBrixModel::ComputeModelfunction(const ParametersType& parameters)
 const
 {
   if (m_TimeGrid.GetSize() == 0)
   {
     itkExceptionMacro("No Time Grid Set! Cannot Calculate Signal");
   }
 
   if (m_Tau == 0)
   {
     itkExceptionMacro("Injection time is 0! Cannot Calculate Signal");
   }
 
+
   ModelResultType signal(m_TimeGrid.GetSize());
 
   double tx        = 0;
   double amplitude = parameters[POSITION_PARAMETER_A];
   double       kel = parameters[POSITION_PARAMETER_kel];
   double       kep = parameters[POSITION_PARAMETER_kep];
   double      tlag = parameters[POSITION_PARAMETER_tlag];
 
+  if (kep == kel)
+  {
+    itkExceptionMacro("(kep-kel) is 0! Cannot Calculate Signal");
+  }
+
   TimeGridType::const_iterator timeGridEnd = m_TimeGrid.end();
   ModelResultType::iterator signalPos = signal.begin();
 
   for (TimeGridType::const_iterator gridPos = m_TimeGrid.begin(); gridPos != timeGridEnd;
        ++gridPos, ++signalPos)
   {
     double t = (*gridPos) / 60.0; //convert from [sec] to [min]
 
 
     if (t <= tlag)
     {
       tx = 0;
     }
     else if ((t > tlag) && (t < (m_Tau + tlag)))
     {
       tx = t - tlag;
     }
     else if (t >= (m_Tau + tlag))
     {
       tx = m_Tau;
     }
 
     double kDiff  = kep - kel;
     double tDiff  = t - tlag;
 
     double expkel   = (kep * exp(-kel * tDiff));
     double expkeltx =        exp(kel * tx);
     double expkep   =        exp(-kep * tDiff);
     double expkeptx =        exp(kep * tx);
 
     double value =  1 + (amplitude / m_Tau) * (((expkel / (kel * kDiff)) * (expkeltx - 1)) - ((
                       expkep / kDiff)  * (expkeptx - 1)));
 
     *signalPos = value * m_S0;
   }
 
   return signal;
 
 }
 
 void mitk::DescriptivePharmacokineticBrixModel::SetStaticParameter(const ParameterNameType& name,
     const StaticParameterValuesType& values)
 {
   if (name == NAME_STATIC_PARAMETER_Tau)
   {
     SetTau(values[0]);
   }
 
   if (name == NAME_STATIC_PARAMETER_S0)
   {
     SetS0(values[0]);
   }
 };
 
 mitk::DescriptivePharmacokineticBrixModel::StaticParameterValuesType
 mitk::DescriptivePharmacokineticBrixModel::GetStaticParameterValue(const ParameterNameType& name)
 const
 {
   StaticParameterValuesType result;
 
   if (name == NAME_STATIC_PARAMETER_Tau)
   {
     result.push_back(GetTau());
   }
 
   if (name == NAME_STATIC_PARAMETER_S0)
   {
     result.push_back(GetS0());
   }
 
   return result;
 };
 
 itk::LightObject::Pointer mitk::DescriptivePharmacokineticBrixModel::InternalClone() const
 {
   DescriptivePharmacokineticBrixModel::Pointer newClone = DescriptivePharmacokineticBrixModel::New();
 
   newClone->SetTimeGrid(this->m_TimeGrid);
   newClone->SetTau(this->m_Tau);
   newClone->SetS0(this->m_S0);
 
   return newClone.GetPointer();
 };
 
 void mitk::DescriptivePharmacokineticBrixModel::PrintSelf(std::ostream& os,
     ::itk::Indent indent) const
 {
   Superclass::PrintSelf(os, indent);
 
   os << indent << "Tau (injection time): " << m_Tau;
   os << indent << "S0 (base value): " << m_S0;
 };
diff --git a/Modules/Pharmacokinetics/test/mitkDescriptivePharmacokineticBrixModelTest.cpp b/Modules/Pharmacokinetics/test/mitkDescriptivePharmacokineticBrixModelTest.cpp
index e6035ab22b..acb5b64ca1 100644
--- a/Modules/Pharmacokinetics/test/mitkDescriptivePharmacokineticBrixModelTest.cpp
+++ b/Modules/Pharmacokinetics/test/mitkDescriptivePharmacokineticBrixModelTest.cpp
@@ -1,60 +1,165 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
+// Testing
 #include "mitkTestingMacros.h"
-#include "mitkVector.h"
+#include "mitkTestFixture.h"
 
+//MITK includes
+#include "mitkVector.h"
 #include "mitkDescriptivePharmacokineticBrixModel.h"
 
+class mitkDescriptivePharmacokineticBrixModelTestSuite : public mitk::TestFixture
+{
+  CPPUNIT_TEST_SUITE(mitkDescriptivePharmacokineticBrixModelTestSuite);
+  MITK_TEST(GetModelDisplayNameTest);
+  MITK_TEST(GetModelTypeTest);
+  MITK_TEST(GetXAxisNameTest);
+  MITK_TEST(GetXAxisUnitTest);
+  MITK_TEST(GetYAxisNameTest);
+  MITK_TEST(GetYAxisUnitTest);
+  MITK_TEST(GetParameterNamesTest);
+  MITK_TEST(GetNumberOfParametersTest);
+  MITK_TEST(GetParameterUnitsTest);
+  MITK_TEST(GetStaticParameterNamesTest);
+  MITK_TEST(GetNumberOfStaticParametersTest);
+  MITK_TEST(GetStaticParameterUnitsTest);
+  MITK_TEST(ComputeModelfunctionTest);
+  CPPUNIT_TEST_SUITE_END();
+
+  private:
+    mitk::DescriptivePharmacokineticBrixModel::Pointer m_testmodel;
+    std::string NAME_PARAMETER_A, POSITION_PARAMETER_kep, POSITION_PARAMETER_kel, POSITION_PARAMETER_tlag;
+    mitk::ModelBase::ModelResultType m_output;
+
+  public:
+    void setUp() override
+    {
+      mitk::ModelBase::TimeGridType m_grid(22);
+      mitk::ModelBase::ParametersType m_testparameters(4);
+
+      m_testparameters[mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_A] = 1.25;
+      m_testparameters(mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_kep) = 3.89;
+      m_testparameters(mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_kel) = 0.12;
+      m_testparameters(mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_tlag) = 1.14;
+
+      for (int i = 0; i < 22; ++i)
+      {
+        // time grid in seconds, 14s between frames
+        m_grid[i] = (double)14 * i;
+      }
+      //injection time in minutes --> 30s
+      double m_injectiontime = 0.5;
+      m_testmodel = mitk::DescriptivePharmacokineticBrixModel::New();
+      m_testmodel->SetTimeGrid(m_grid);
+      m_testmodel->SetTau(m_injectiontime);
+
+      //ComputeModelfunction is called within GetSignal(), therefore no explicit testing of ComputeModelFunction()
+      m_output = m_testmodel->GetSignal(m_testparameters);
+    }
 
+    void tearDown() override
+    {
+      m_testmodel = nullptr;
+      NAME_PARAMETER_A = "";
+      POSITION_PARAMETER_kep = "";
+      POSITION_PARAMETER_kel = "";
+      POSITION_PARAMETER_tlag = "";
+      m_output.clear();
+    }
+
+    void GetModelDisplayNameTest()
+    {
+      m_testmodel->GetModelDisplayName();
+      CPPUNIT_ASSERT_MESSAGE("Checking model display name.", m_testmodel->GetModelDisplayName() == "Descriptive Pharmacokinetic Brix Model");
+    }
+
+    void GetModelTypeTest()
+    {
+      CPPUNIT_ASSERT_MESSAGE("Checking model type.", m_testmodel->GetModelType() == "Perfusion.MR");
+    }
+
+    void GetXAxisNameTest()
+    {
+      CPPUNIT_ASSERT_MESSAGE("Checking x-axis name.", m_testmodel->GetXAxisName() == "Time");
+    }
+
+    void GetXAxisUnitTest()
+    {
+      CPPUNIT_ASSERT_MESSAGE("Checking x-axis unit", m_testmodel->GetXAxisUnit() == "s");
+    }
 
-int mitkDescriptivePharmacokineticBrixModelTest(int  /*argc*/ , char*[] /*argv[]*/){
+    void GetYAxisNameTest()
+    {
+      CPPUNIT_ASSERT_MESSAGE("Checking y-axis name.", m_testmodel->GetYAxisName() == "");
+    }
 
-    MITK_TEST_BEGIN("DescriptivePharmacokineticBrixModel")
+    void GetYAxisUnitTest()
+    {
+      CPPUNIT_ASSERT_MESSAGE("Checking y-axis unit", m_testmodel->GetYAxisUnit() == "");
+    }
 
-    mitk::ModelBase::TimeGridType grid(22);
-    mitk::ModelBase::ModelResultType output;
-    mitk::ModelBase::ParametersType testparameters(4);
+    void GetParameterNamesTest()
+    {
+      mitk::DescriptivePharmacokineticBrixModel::ParameterNamesType parameterNames;
+      parameterNames.push_back("A");
+      parameterNames.push_back("kep");
+      parameterNames.push_back("kel");
+      parameterNames.push_back("tlag");
+      CPPUNIT_ASSERT_MESSAGE("Checking parameter names.", m_testmodel->GetParameterNames() == parameterNames);
+    }
 
-    testparameters[mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_A] = 1.25;
-    testparameters(mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_kep) = 3.89;
-    testparameters(mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_kel) = 0.12;
-    testparameters(mitk::DescriptivePharmacokineticBrixModel::POSITION_PARAMETER_tlag) = 1.14;
+    void GetNumberOfParametersTest()
+    {
+      CPPUNIT_ASSERT_MESSAGE("Checking number of parameters in model.", m_testmodel->GetNumberOfParameters() == 4);
+    }
 
+    void GetParameterUnitsTest()
+    {
+      mitk::DescriptivePharmacokineticBrixModel::ParamterUnitMapType parameterUnitMap;
+      parameterUnitMap.insert(std::make_pair("A", "a.u."));
+      parameterUnitMap.insert(std::make_pair("kep", "1/min"));
+      parameterUnitMap.insert(std::make_pair("kel", "1/min"));
+      parameterUnitMap.insert(std::make_pair("tlag", "min"));
+      CPPUNIT_ASSERT_MESSAGE("Checking parameter unit map.", m_testmodel->GetParameterUnits() == parameterUnitMap);
+    }
 
+    void GetStaticParameterNamesTest()
+    {
+      mitk::DescriptivePharmacokineticBrixModel::ParameterNamesType staticParameterNames;
+      staticParameterNames.push_back("Tau");
+      staticParameterNames.push_back("S0");
+      CPPUNIT_ASSERT_MESSAGE("Checking static parameter names.", m_testmodel->GetStaticParameterNames() == staticParameterNames);
+    }
 
-    for (int i = 0; i<22; ++i)
+    void GetNumberOfStaticParametersTest()
     {
-   // time grid in seconds, 14s between frames
-      grid[i]=(double) 14*i;
+      CPPUNIT_ASSERT_MESSAGE("Checking number of static parameters.", m_testmodel->GetNumberOfStaticParameters() == 2);
     }
-    //injection time in minutes --> 60s
-    double injectiontime = 0.5;
-    mitk::DescriptivePharmacokineticBrixModel::Pointer testmodel = mitk::DescriptivePharmacokineticBrixModel::New();
-    testmodel->SetTimeGrid(grid);
-    testmodel->SetTau(injectiontime);
 
-    CPPUNIT_ASSERT_MESSAGE("Check number of parameters in Model.", 4 == testmodel->GetNumberOfParameters());
-    output = testmodel->GetSignal(testparameters);
-    //precision of output ?
-    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(1,output[0], 1e-6, true)==true,"Check Output signal values - 0");
-    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(1,output[4], 1e-6, true)==true,"Check Output signal values - 4");
-    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(1.003338,output[5], 1e-6, true)==true,"Check Output signal values - 5");
-    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(1.238392,output[6], 1e-6, true)==true,"Check Output signal values - 6");
-    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(1.669835,output[7], 1e-6, true)==true,"Check Output signal values - 7");
-    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(1.982948,output[8], 1e-6, true)==true,"Check Output signal values - 8");
-    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(2.089685,output[9], 1e-6, true)==true,"Check Output signal values - 9");
-    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(2.113611,output[10], 1e-6, true)==true,"Check Output signal values - 10");
+    void GetStaticParameterUnitsTest()
+    {
+      mitk::DescriptivePharmacokineticBrixModel::ParamterUnitMapType staticParameterUnitMap;
+      staticParameterUnitMap.insert(std::make_pair("Tau", "min"));
+      staticParameterUnitMap.insert(std::make_pair("S0", "I"));
+      CPPUNIT_ASSERT_MESSAGE("Checking static parameters units.", m_testmodel->GetStaticParameterUnits() == staticParameterUnitMap);
+    }
 
-    MITK_TEST_END()
+    void ComputeModelfunctionTest()
+    {
+      CPPUNIT_ASSERT_MESSAGE("Checking signal of parameter set 1 at time frame 0.", mitk::Equal(1, m_output[0], 1e-6, true) == true);
+      CPPUNIT_ASSERT_MESSAGE("Checking signal of parameter set 1 at time frame 10.",mitk::Equal(2.113611, m_output[10], 1e-6, true) == true);
+      CPPUNIT_ASSERT_MESSAGE("Checking signal of parameter set 1 at time frame 20.", mitk::Equal(1.870596, m_output[20], 1e-6, true) == true);
+    }
+};
 
-}
+MITK_TEST_SUITE_REGISTRATION(mitkDescriptivePharmacokineticBrixModel)
diff --git a/Modules/QtWidgets/include/QmitkAbstractDataStorageModel.h b/Modules/QtWidgets/include/QmitkAbstractDataStorageModel.h
index 5d4f0f9123..d267484d6b 100644
--- a/Modules/QtWidgets/include/QmitkAbstractDataStorageModel.h
+++ b/Modules/QtWidgets/include/QmitkAbstractDataStorageModel.h
@@ -1,88 +1,88 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKABSTRACTDATASTORAGEMODEL_H
 #define QMITKABSTRACTDATASTORAGEMODEL_H
 
 #include <MitkQtWidgetsExports.h>
 
 // mitk core
 #include <mitkDataStorage.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkWeakPointer.h>
 
 // qt
 #include <QAbstractItemModel>
 
 /*
 * @brief This abstract class extends the 'QAbstractItemModel' to accept an 'mitk::DataStorage' and a 'mitk::NodePredicateBase'.
 *   It registers itself as a node event listener of the data storage.
 *   The 'QmitkAbstractDataStorageModel' provides three empty functions, 'NodeAdded', 'NodeChanged' and 'NodeRemoved', that
 *   may be implemented by subclasses. These functions allow to react to the 'AddNodeEvent', 'ChangedNodeEvent' and
 *   'RemoveNodeEvent' of the data storage. This might be useful to force an update on a custom view to correctly
 *   represent the content of the data storage.
 *
 *   A concrete implementation of this class is used to store the temporarily shown data nodes of the data storage.
 *   These nodes may be a subset of all the nodes inside the data storage, if a specific node predicate is set.
 *
 *   A model that implements this class has to return mitk::DataNode::Pointer objects for model indexes when the
 *   role is QmitkDataNodeRole.
 */
 class MITKQTWIDGETS_EXPORT QmitkAbstractDataStorageModel : public QAbstractItemModel
 {
   Q_OBJECT
 
 public:
 
   ~QmitkAbstractDataStorageModel() override;
   /*
   * @brief Sets the data storage and adds listener for node events.
   *
   * @param dataStorage      A pointer to the data storage to set.
   */
   void SetDataStorage(mitk::DataStorage* dataStorage);
 
-  mitk::DataStorage* GetDataStorage() const;
+  mitk::DataStorage::Pointer GetDataStorage() const;
   /*
   * @brief Sets the node predicate and updates the model data, according to the node predicate.
   *
   * @param nodePredicate    A pointer to node predicate.
   */
   void SetNodePredicate(const mitk::NodePredicateBase* nodePredicate);
 
   const mitk::NodePredicateBase* GetNodePredicate() const { return m_NodePredicate; }
 
 protected:
 
   virtual void DataStorageChanged() = 0;
   virtual void NodePredicateChanged() = 0;
 
   virtual void NodeAdded(const mitk::DataNode* node) = 0;
   virtual void NodeChanged(const mitk::DataNode* node) = 0;
   virtual void NodeRemoved(const mitk::DataNode* node) = 0;
 
   QmitkAbstractDataStorageModel(QObject* parent = nullptr);
   QmitkAbstractDataStorageModel(mitk::DataStorage* dataStorage, QObject* parent = nullptr);
 
   mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
   mitk::NodePredicateBase::ConstPointer m_NodePredicate;
 
 private:
 
   /** Helper triggered on the storage delete event */
   void SetDataStorageDeleted();
 
   unsigned long m_DataStorageDeletedTag;
 
 };
 
 #endif // QMITKABSTRACTDATASTORAGEMODEL_H
diff --git a/Modules/QtWidgets/include/QmitkRenderWindowMenu.h b/Modules/QtWidgets/include/QmitkRenderWindowMenu.h
index 275f0176cd..f0f96cb4db 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindowMenu.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindowMenu.h
@@ -1,194 +1,194 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKRENDERWINDOWMENU_H
 #define QMITKRENDERWINDOWMENU_H
 
 // mitk qtwidgets module
 #include "MitkQtWidgetsExports.h"
 #include "QmitkMultiWidgetLayoutManager.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 
 // qt
 #include <QAction>
 #include <QEvent>
 #include <QLabel>
 #include <QMenuBar>
 #include <QPushButton>
 #include <QTimer>
 #include <QToolButton>
 #include <QWidget>
 
 /**
  * \ingroup QmitkModule
  * \brief The QmitkRenderWindowMenu is a popup Widget which shows
  * up when the mouse cursor enter a QmitkRenderWindow.
  * The Menu Widget is located in the right top corner of each
  * RenderWindow. It includes different settings. For example
  * the layout design can be changed with the setting button. Switching
  * between full-screen mode and layout design can be done
  * with the full-screen button.
  * The popup Widget can be deactivated with ActivateMenuWidget(false) in
  * QmitkRenderWindow.
  *
  * \sa QmitkRenderWindow
  *
  */
 class MITKQTWIDGETS_EXPORT QmitkRenderWindowMenu : public QWidget
 {
   Q_OBJECT
 
 public:
 
   using LayoutIndex = mitk::BaseRenderer::ViewDirection;
   using LayoutDesign = QmitkMultiWidgetLayoutManager::LayoutDesign;
 
   QmitkRenderWindowMenu(QWidget *parent = nullptr,
                         Qt::WindowFlags f = nullptr,
                         mitk::BaseRenderer *b = nullptr);
   ~QmitkRenderWindowMenu() override;
 
   /*! Return visibility of settings menu. The menu is connected with m_SettingsButton and includes
   layout direction (axial, coronal .. ) and layout design (standard layout, 2D images top,
   3D bottom ... ). */
   bool GetSettingsMenuVisibilty()
   {
     if (m_LayoutActionsMenu == nullptr)
       return false;
     else
       return m_LayoutActionsMenu->isVisible();
   }
 
-  /*! Set layout index. Defines layout direction (axial, coronal, sagital or threeD) of the parent. */
+  /*! Set layout index. Defines layout direction (axial, coronal, sagittal or threeD) of the parent. */
   void SetLayoutIndex(LayoutIndex layoutIndex);
 
-  /*! Return layout direction of parent (axial, coronal, sagital or threeD) */
+  /*! Return layout direction of parent (axial, coronal, sagittal or threeD) */
   LayoutIndex GetLayoutIndex() { return m_Layout; }
   /*! Update list of layout design (standard layout, 2D images top, 3D bottom ..). Set action of current layout design
   to disable and all other to enable. */
   void UpdateLayoutDesignList(LayoutDesign layoutDesign);
 
   void UpdateCrosshairVisibility(bool visible);
 
   void UpdateCrosshairRotationMode(int mode);
 
 /*! Move menu widget to correct position (right upper corner). E.g. it is necessary when the full-screen mode
 is activated.*/
   void MoveWidgetToCorrectPos();
 
   void ShowMenu();
   void HideMenu();
 
 protected:
 
   /*! Reimplemented from QWidget. The paint event is a request to repaint all or part of a widget.*/
   void paintEvent(QPaintEvent *event) override;
 
   void CreateMenuWidget();
 
   /*! Create settings menu which contains layout direction and the different layout designs. */
   void CreateSettingsWidget();
 
   /*! Change Icon of full-screen button depending on full-screen mode. */
   void ChangeFullScreenIcon();
 
 Q_SIGNALS:
 
   void ResetView(); // == "global reinit"
 
   void CrosshairVisibilityChanged(bool);
 
   // \brief int parameters are enum from QmitkStdMultiWidget
   void CrosshairRotationModeChanged(int);
 
   /*! emit signal, when layout design changed by the setting menu.*/
   void LayoutDesignChanged(LayoutDesign layoutDesign);
 
 protected Q_SLOTS:
 
   /// this function is continuously called by a timer
   /// to do the auto rotation
   void AutoRotateNextStep();
 
   /// this function is invoked when the auto-rotate action
   /// is clicked
   void OnAutoRotationActionTriggered();
 
   void OnTSNumChanged(int);
 
   void OnCrosshairMenuAboutToShow();
   void OnCrosshairVisibilityChanged(bool);
   void OnCrosshairRotationModeSelected(QAction *);
 
   /*! slot for activating/deactivating the full-screen mode. The slot is connected to the clicked() event of
   m_FullScreenButton.
   Activating the full-screen maximize the current widget, deactivating restore If layout design changed by the settings
   menu, the full-Screen mode is automatically switched to false. */
   void OnFullScreenButton(bool checked);
 
   /*! Slot for opening setting menu. The slot is connected to the clicked() event of m_SettingsButton.
   The settings menu includes different layout directions (axial, coronal, sagittal and 3D) as well all layout design
   (standard layout, 2D images top, 3D bottom ..)*/
   void OnLayoutDesignButton(bool checked);
 
   void OnSetLayout(LayoutDesign layoutDesign);
 
 protected:
 
   QToolButton* m_CrosshairModeButton;
 
   QToolButton* m_FullScreenButton;
 
   QToolButton* m_LayoutDesignButton;
   QMenu* m_LayoutActionsMenu;
   QAction* m_DefaultLayoutAction;
   QAction* m_All2DTop3DBottomLayoutAction;
   QAction* m_All2DLeft3DRightLayoutAction;
   QAction* m_OneBigLayoutAction;
   QAction* m_Only2DHorizontalLayoutAction;
   QAction* m_Only2DVerticalLayoutAction;
   QAction* m_OneTop3DBottomLayoutAction;
   QAction* m_OneLeft3DRightLayoutAction;
   QAction* m_AllHorizontalLayoutAction;
   QAction* m_AllVerticalLayoutAction;
   QAction* m_RemoveOneLayoutAction;
 
   QLabel *m_TSLabel;
 
   QMenu *m_CrosshairMenu;
 
   /*! Flag if full-screen mode is activated or deactivated. */
   bool m_FullScreenMode;
 
 private:
 
   mitk::BaseRenderer::Pointer m_Renderer;
 
   QTimer* m_AutoRotationTimer;
 
   QWidget *m_Parent;
 
   //memory because mode is set to default for slice num = 1
   static unsigned int m_DefaultThickMode;
 
   int m_CrosshairRotationMode;
   bool m_CrosshairVisibility;
 
   LayoutIndex m_Layout;
   LayoutDesign m_LayoutDesign;
   LayoutDesign m_OldLayoutDesign;
 
 };
 
 #endif // QMITKRENDERWINDOWMENU_H
diff --git a/Modules/QtWidgets/src/QmitkAbstractDataStorageInspector.cpp b/Modules/QtWidgets/src/QmitkAbstractDataStorageInspector.cpp
index 96efdd6282..61ad49c2c9 100644
--- a/Modules/QtWidgets/src/QmitkAbstractDataStorageInspector.cpp
+++ b/Modules/QtWidgets/src/QmitkAbstractDataStorageInspector.cpp
@@ -1,79 +1,80 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkAbstractDataStorageInspector.h>
 
 QmitkAbstractDataStorageInspector::QmitkAbstractDataStorageInspector(QWidget* parent/* = nullptr*/)
   : QWidget(parent)
   , m_NodePredicate(nullptr)
 {
   m_Connector = std::make_unique<QmitkModelViewSelectionConnector>();
 
   connect(m_Connector.get(), &QmitkModelViewSelectionConnector::CurrentSelectionChanged, this, &QmitkAbstractDataStorageInspector::OnSelectionChanged);
 }
 
 QmitkAbstractDataStorageInspector::~QmitkAbstractDataStorageInspector()
 {
 }
 
 void QmitkAbstractDataStorageInspector::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage != dataStorage)
   {
     m_DataStorage = dataStorage;
+    auto lockedDataStorage = m_DataStorage.Lock();
 
-    if (!m_DataStorage.IsExpired())
+    if (lockedDataStorage.IsNotNull())
     {
       this->Initialize();
     }
   }
 }
 
 void QmitkAbstractDataStorageInspector::SetNodePredicate(const mitk::NodePredicateBase* nodePredicate)
 {
   if (m_NodePredicate != nodePredicate)
   {
     m_NodePredicate = nodePredicate;
 
     this->Initialize();
   }
 }
 
 const mitk::NodePredicateBase* QmitkAbstractDataStorageInspector::GetNodePredicate() const
 {
   return m_NodePredicate;
 }
 
 QmitkAbstractDataStorageInspector::NodeList QmitkAbstractDataStorageInspector::GetSelectedNodes() const
 {
   return m_Connector->GetSelectedNodes();
 }
 
 bool QmitkAbstractDataStorageInspector::GetSelectOnlyVisibleNodes() const
 {
   return m_Connector->GetSelectOnlyVisibleNodes();
 }
 
 void QmitkAbstractDataStorageInspector::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
 {
   m_Connector->SetSelectOnlyVisibleNodes(selectOnlyVisibleNodes);
 }
 
 void QmitkAbstractDataStorageInspector::SetCurrentSelection(NodeList selectedNodes)
 {
   m_Connector->SetCurrentSelection(selectedNodes);
 }
 
 void QmitkAbstractDataStorageInspector::OnSelectionChanged(NodeList selectedNodes)
 {
   emit CurrentSelectionChanged(selectedNodes);
 }
diff --git a/Modules/QtWidgets/src/QmitkAbstractDataStorageModel.cpp b/Modules/QtWidgets/src/QmitkAbstractDataStorageModel.cpp
index 5718d7e938..719a96cf37 100644
--- a/Modules/QtWidgets/src/QmitkAbstractDataStorageModel.cpp
+++ b/Modules/QtWidgets/src/QmitkAbstractDataStorageModel.cpp
@@ -1,130 +1,115 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkAbstractDataStorageModel.h>
 
 QmitkAbstractDataStorageModel::QmitkAbstractDataStorageModel(QObject* parent/* = nullptr*/)
   : QAbstractItemModel(parent)
   , m_DataStorage(nullptr)
   , m_NodePredicate(nullptr)
 {
   // nothing here
 }
 
 QmitkAbstractDataStorageModel::QmitkAbstractDataStorageModel(mitk::DataStorage* dataStorage, QObject* parent/* = nullptr*/)
   : QAbstractItemModel(parent)
   , m_DataStorage(nullptr)
   , m_NodePredicate(nullptr)
 {
   SetDataStorage(dataStorage);
 }
 
 QmitkAbstractDataStorageModel::~QmitkAbstractDataStorageModel()
 {
-  if (!m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
-
-    if (dataStorage.IsNotNull())
-    {
-      // remove Listener for the data storage itself
-      dataStorage->RemoveObserver(m_DataStorageDeletedTag);
-
-      // remove listener from data storage
-      dataStorage->AddNodeEvent.RemoveListener(
-        mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
-      dataStorage->RemoveNodeEvent.RemoveListener(
-        mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
-      dataStorage->ChangedNodeEvent.RemoveListener(
-        mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
-    }
+    // remove Listener for the data storage itself
+    dataStorage->RemoveObserver(m_DataStorageDeletedTag);
+
+    // remove listener from data storage
+    dataStorage->AddNodeEvent.RemoveListener(
+      mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
+    dataStorage->RemoveNodeEvent.RemoveListener(
+      mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
+    dataStorage->ChangedNodeEvent.RemoveListener(
+      mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
   }
 }
 
 void QmitkAbstractDataStorageModel::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage == dataStorage)
   {
     return;
   }
 
-  if (!m_DataStorage.IsExpired())
+  auto lockedDataStorage = m_DataStorage.Lock();
+
+  if (lockedDataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
-
-    if (dataStorage.IsNotNull())
-    {
-      // remove Listener for the data storage itself
-      dataStorage->RemoveObserver(m_DataStorageDeletedTag);
-
-      // remove listener from old data storage
-      dataStorage->AddNodeEvent.RemoveListener(
-        mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
-      dataStorage->RemoveNodeEvent.RemoveListener(
-        mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
-      dataStorage->ChangedNodeEvent.RemoveListener(
-        mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
-    }
+    // remove Listener for the data storage itself
+    lockedDataStorage->RemoveObserver(m_DataStorageDeletedTag);
+
+    // remove listener from old data storage
+    lockedDataStorage->AddNodeEvent.RemoveListener(
+      mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
+    lockedDataStorage->RemoveNodeEvent.RemoveListener(
+      mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
+    lockedDataStorage->ChangedNodeEvent.RemoveListener(
+      mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
   }
 
   m_DataStorage = dataStorage;
+  lockedDataStorage = m_DataStorage.Lock();
 
-  if (!m_DataStorage.IsExpired())
+  if (lockedDataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
-
-    if (dataStorage.IsNotNull())
-    {
-      // add Listener for the data storage itself
-      auto command = itk::SimpleMemberCommand<QmitkAbstractDataStorageModel>::New();
-      command->SetCallbackFunction(this, &QmitkAbstractDataStorageModel::SetDataStorageDeleted);
-      m_DataStorageDeletedTag = dataStorage->AddObserver(itk::DeleteEvent(), command);
-
-      // add listener for new data storage
-      dataStorage->AddNodeEvent.AddListener(
-        mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
-      dataStorage->RemoveNodeEvent.AddListener(
-        mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
-      dataStorage->ChangedNodeEvent.AddListener(
-        mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
-    }
+    // add Listener for the data storage itself
+    auto command = itk::SimpleMemberCommand<QmitkAbstractDataStorageModel>::New();
+    command->SetCallbackFunction(this, &QmitkAbstractDataStorageModel::SetDataStorageDeleted);
+    m_DataStorageDeletedTag = lockedDataStorage->AddObserver(itk::DeleteEvent(), command);
+
+    // add listener for new data storage
+    lockedDataStorage->AddNodeEvent.AddListener(
+      mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeAdded));
+    lockedDataStorage->RemoveNodeEvent.AddListener(
+      mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeRemoved));
+    lockedDataStorage->ChangedNodeEvent.AddListener(
+      mitk::MessageDelegate1<QmitkAbstractDataStorageModel, const mitk::DataNode*>(this, &QmitkAbstractDataStorageModel::NodeChanged));
   }
   // update model if the data storage has been changed
   DataStorageChanged();
 }
 
-mitk::DataStorage* QmitkAbstractDataStorageModel::GetDataStorage() const
+mitk::DataStorage::Pointer QmitkAbstractDataStorageModel::GetDataStorage() const
 {
-  if (m_DataStorage.IsExpired())
-  {
-    return nullptr;
-  }
-
-  return m_DataStorage.Lock().GetPointer();
+  return m_DataStorage.Lock();
 }
 
 void QmitkAbstractDataStorageModel::SetDataStorageDeleted()
 {
   this->SetDataStorage(nullptr);
 }
 
 void QmitkAbstractDataStorageModel::SetNodePredicate(const mitk::NodePredicateBase* nodePredicate)
 {
   if (m_NodePredicate == nodePredicate)
   {
     return;
   }
 
   m_NodePredicate = nodePredicate;
   // update model if the node predicate has been changed
   NodePredicateChanged();
 }
diff --git a/Modules/QtWidgets/src/QmitkDataStorageComboBox.cpp b/Modules/QtWidgets/src/QmitkDataStorageComboBox.cpp
index 8620733a7c..6f775ea6c6 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageComboBox.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageComboBox.cpp
@@ -1,467 +1,467 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkDataStorageComboBox.h"
 
 #include <itkCommand.h>
 
 QmitkDataStorageComboBox::QmitkDataStorageComboBox(QWidget *parent, bool autoSelectNewNodes)
   : QComboBox(parent),
     m_DataStorage(nullptr),
     m_Predicate(nullptr),
     m_BlockEvents(false),
     m_AutoSelectNewNodes(autoSelectNewNodes)
 {
   this->Init();
 }
 
 QmitkDataStorageComboBox::QmitkDataStorageComboBox(mitk::DataStorage *dataStorage,
                                                    const mitk::NodePredicateBase *predicate,
                                                    QWidget *parent,
                                                    bool autoSelectNewNodes)
   : QComboBox(parent),
     m_DataStorage(nullptr),
     m_Predicate(predicate),
     m_BlockEvents(false),
     m_AutoSelectNewNodes(autoSelectNewNodes)
 {
   // make connections, fill combobox
   this->Init();
   this->SetDataStorage(dataStorage);
 }
 
 QmitkDataStorageComboBox::~QmitkDataStorageComboBox()
 {
+  auto dataStorage = m_DataStorage.Lock();
+
   // if there was an old storage, remove listeners
-  if (!m_DataStorage.IsExpired())
+  if (dataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
-
     dataStorage->AddNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkDataStorageComboBox, const mitk::DataNode *>(this,
                                                                                &QmitkDataStorageComboBox::AddNode));
 
     dataStorage->RemoveNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkDataStorageComboBox, const mitk::DataNode *>(this,
                                                                                &QmitkDataStorageComboBox::RemoveNode));
   }
   // we have lots of observers to nodes and their name properties, this gets ugly if nodes live longer than the box
   while (m_Nodes.size() > 0)
     RemoveNode(0);
 }
 
 int QmitkDataStorageComboBox::Find(const mitk::DataNode *dataNode) const
 {
   std::iterator_traits<mitk::DataNode*>::difference_type index = -1;
 
   auto nodeIt = std::find(m_Nodes.begin(), m_Nodes.end(), dataNode);
 
   if (nodeIt != m_Nodes.end())
     index = std::distance(m_Nodes.begin(), nodeIt);
 
   return static_cast<int>(index);
 }
 
 mitk::DataStorage::Pointer QmitkDataStorageComboBox::GetDataStorage() const
 {
   return m_DataStorage.Lock();
 }
 
 const mitk::NodePredicateBase::ConstPointer QmitkDataStorageComboBox::GetPredicate() const
 {
   return m_Predicate.GetPointer();
 }
 
 mitk::DataNode::Pointer QmitkDataStorageComboBox::GetNode(int index) const
 {
   return (this->HasIndex(index)) ? m_Nodes.at(index) : nullptr;
 }
 
 mitk::DataNode::Pointer QmitkDataStorageComboBox::GetSelectedNode() const
 {
   if (this->count() == 0)
     return nullptr;
 
   int currentIndex = this->currentIndex();
 
   return currentIndex >= 0 ? this->GetNode(currentIndex) : nullptr;
 }
 
 mitk::DataStorage::SetOfObjects::ConstPointer QmitkDataStorageComboBox::GetNodes() const
 {
   mitk::DataStorage::SetOfObjects::Pointer setOfObjects = mitk::DataStorage::SetOfObjects::New();
 
   for (auto it = m_Nodes.begin(); it != m_Nodes.end(); ++it)
   {
     setOfObjects->push_back(*it);
   }
 
   return setOfObjects.GetPointer();
 }
 
 bool QmitkDataStorageComboBox::GetAutoSelectNewItems()
 {
   return m_AutoSelectNewNodes;
 }
 
 void QmitkDataStorageComboBox::SetDataStorage(mitk::DataStorage *dataStorage)
 {
   auto currentDataStorage = m_DataStorage.Lock();
 
   // reset only if datastorage really changed
   if (currentDataStorage.GetPointer() != dataStorage)
   {
     // if there was an old storage, remove listeners
     if (currentDataStorage.IsNotNull())
     {
       currentDataStorage->AddNodeEvent.RemoveListener(
         mitk::MessageDelegate1<QmitkDataStorageComboBox, const mitk::DataNode *>(this,
           &QmitkDataStorageComboBox::AddNode));
 
       currentDataStorage->RemoveNodeEvent.RemoveListener(
         mitk::MessageDelegate1<QmitkDataStorageComboBox, const mitk::DataNode *>(this,
           &QmitkDataStorageComboBox::RemoveNode));
     }
     // set new storage
     m_DataStorage = dataStorage;
+    currentDataStorage = m_DataStorage.Lock();
 
     // if there is a new storage, add listeners
-    if (!m_DataStorage.IsExpired())
+    if (currentDataStorage.IsNotNull())
     {
-      currentDataStorage = m_DataStorage.Lock();
-
       currentDataStorage->AddNodeEvent.AddListener(
         mitk::MessageDelegate1<QmitkDataStorageComboBox, const mitk::DataNode *>(this,
           &QmitkDataStorageComboBox::AddNode));
 
       currentDataStorage->RemoveNodeEvent.AddListener(
         mitk::MessageDelegate1<QmitkDataStorageComboBox, const mitk::DataNode *>(this,
           &QmitkDataStorageComboBox::RemoveNode));
     }
 
     // reset predicate to reset the combobox
     this->Reset();
   }
 }
 
 void QmitkDataStorageComboBox::SetPredicate(const mitk::NodePredicateBase *predicate)
 {
   if (m_Predicate != predicate)
   {
     m_Predicate = predicate;
     this->Reset();
   }
 }
 
 void QmitkDataStorageComboBox::AddNode(const mitk::DataNode *dataNode)
 {
   // this is an event function, make sure that we didn't call ourself
   if (!m_BlockEvents)
   {
     m_BlockEvents = true;
     // pass a -1 to the InsertNode function in order to append the datatree node to the end
     this->InsertNode(-1, dataNode);
     m_BlockEvents = false;
   }
 }
 
 void QmitkDataStorageComboBox::RemoveNode(int index)
 {
   if (this->HasIndex(index))
   {
     RemoveNodeAndPropertyLists(index);
     // remove node name from combobox
     this->removeItem(index);
   }
 }
 
 void QmitkDataStorageComboBox::RemoveNode(const mitk::DataNode *dataNode)
 {
   // this is an event function, make sure that we didn't call ourself
   if (!m_BlockEvents)
   {
     m_BlockEvents = true;
     this->RemoveNode(this->Find(dataNode));
     m_BlockEvents = false;
   }
 }
 
 void QmitkDataStorageComboBox::SetNode(int index, const mitk::DataNode *dataNode)
 {
   if (this->HasIndex(index))
   {
     // if node is identical, we only update the name in the QComboBoxItem
     if (dataNode == m_Nodes.at(index))
     {
       this->setItemText(index, QString::fromStdString(dataNode->GetName()));
     }
     else
     {
       this->InsertNode(index, dataNode);
     }
   }
 }
 
 void QmitkDataStorageComboBox::SetNode(const mitk::DataNode *dataNode, const mitk::DataNode *otherDataNode)
 {
   this->SetNode(this->Find(dataNode), otherDataNode);
 }
 
 void QmitkDataStorageComboBox::SetAutoSelectNewItems(bool autoSelectNewItems)
 {
   m_AutoSelectNewNodes = autoSelectNewItems;
 }
 
 void QmitkDataStorageComboBox::OnPropertyListChanged(const itk::Object *caller, const itk::EventObject &event)
 {
   if (!m_BlockEvents)
   {
     m_BlockEvents = true;
 
     // check if we have a modified event
     const itk::ModifiedEvent *modifiedEvent = dynamic_cast<const itk::ModifiedEvent *>(&event);
     if (modifiedEvent)
     {
       const mitk::PropertyList *propertyList = dynamic_cast<const mitk::PropertyList *>(caller);
       UpdateComboBoxText(propertyList);
     }
 
     m_BlockEvents = false;
   }
 }
 
 bool QmitkDataStorageComboBox::HasIndex(unsigned int index) const
 {
   return (m_Nodes.size() > 0 && index < m_Nodes.size());
 }
 
 void QmitkDataStorageComboBox::OnCurrentIndexChanged(int index)
 {
   if (index >= 0 && index < this->count())
     emit OnSelectionChanged(this->GetSelectedNode());
   if (index == -1)
     emit OnSelectionChanged(nullptr);
 }
 
 void QmitkDataStorageComboBox::SetSelectedNode(const mitk::DataNode::Pointer& node)
 {
   int index = this->Find(node);
   if (index == -1)
   {
     MITK_INFO << "QmitkDataStorageComboBox: item not available";
   }
   else
   {
     this->setCurrentIndex(index);
   }
 }
 
 void QmitkDataStorageComboBox::InsertNode(int index, const mitk::DataNode *dataNode)
 {
   // check new or updated node first
   if (m_Predicate.IsNotNull() && !m_Predicate->CheckNode(dataNode))
     return;
 
   bool addNewNode = false;
   bool insertNewNode = false;
   bool changedNode = false;
 
   // if this->HasIndex(index), then a node shall be updated
   if (this->HasIndex(index))
   {
     // if we really have another node at this position then ...
     if (dataNode != m_Nodes.at(index))
     {
       // ... remove node, then proceed as usual
       this->RemoveNode(index);
       insertNewNode = true;
     }
     else
       changedNode = true;
   }
   // otherwise a new node shall be added, let index point to the element after the last element
   else
   {
     index = m_Nodes.size();
     addNewNode = true;
   }
 
   // const cast because we need non const nodes
   mitk::DataNode *nonConstDataNode = const_cast<mitk::DataNode *>(dataNode);
   if (!changedNode)
   {
     // break on duplicated nodes (that doesn't make sense to have duplicates in the combobox)
     if (this->Find(dataNode) != -1)
       return;
 
     // add modified observer
     itk::MemberCommand<QmitkDataStorageComboBox>::Pointer propertyListChangedCommand =
       itk::MemberCommand<QmitkDataStorageComboBox>::New();
     propertyListChangedCommand->SetCallbackFunction(this, &QmitkDataStorageComboBox::OnPropertyListChanged);
 
     // add observer for the data node property list
     mitk::PropertyList* dataNodePropertyList = nonConstDataNode->GetPropertyList();
     if (nullptr != dataNodePropertyList)
     {
       m_DataNodePropertyListObserverTags.push_back(dataNodePropertyList->AddObserver(itk::ModifiedEvent(),
         propertyListChangedCommand));
     }
     else
     {
       // fill vector with invalid value
       m_DataNodePropertyListObserverTags.push_back(-1);
     }
 
     mitk::PropertyList* baseDataPropertyList;
     //add observer for the base data property list
     mitk::BaseData* baseData = dynamic_cast<mitk::BaseData*>(nonConstDataNode->GetData());
     if (nullptr != baseData)
     {
       baseDataPropertyList = baseData->GetPropertyList();
       if (nullptr != baseDataPropertyList)
       {
         m_BaseDatapropertyListObserverTags.push_back(baseDataPropertyList->AddObserver(itk::ModifiedEvent(),
           propertyListChangedCommand));
       }
       else
       {
         // fill vector with invalid value
         m_BaseDatapropertyListObserverTags.push_back(-1);
       }
     }
     else
     {
       // fill vector with invalid value
       m_BaseDatapropertyListObserverTags.push_back(-1);
     }
   }
 
   // add node to the vector
   if (addNewNode)
     m_Nodes.push_back(nonConstDataNode);
   else if (insertNewNode)
     m_Nodes.insert(m_Nodes.begin() + index, nonConstDataNode);
 
   if (addNewNode)
   {
     this->addItem(QString::fromStdString(nonConstDataNode->GetName()));
     // select new node if m_AutoSelectNewNodes is true or if we have just added the first node
     if (m_AutoSelectNewNodes || m_Nodes.size() == 1)
       this->setCurrentIndex(index);
   }
   else
   {
     // update text in combobox
     this->setItemText(index, QString::fromStdString(nonConstDataNode->GetName()));
   }
 }
 
 void QmitkDataStorageComboBox::Init()
 {
   connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(OnCurrentIndexChanged(int)));
 }
 
 void QmitkDataStorageComboBox::Reset()
 {
   // remove all nodes first
   while (!m_Nodes.empty())
   {
     // remove last node
     // explicitly calling RemoveNode of QmitkDataStorageComboBox since derived classes may prevent the removal of all
     // nodes in their respective RemoveNode implementation. This is happening for example in
     // QmitkDataStorageComboBoxWithSelectNone.
     QmitkDataStorageComboBox::RemoveNode(m_Nodes.size() - 1);
   }
 
   // clear combobox
   this->clear();
 
-  if (!m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
     mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects;
 
     // select all if predicate == nullptr
     if (m_Predicate.IsNotNull())
       setOfObjects = dataStorage->GetSubset(m_Predicate);
     else
       setOfObjects = dataStorage->GetAll();
 
     // add all found nodes
     for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin(); nodeIt != setOfObjects->End();
          ++nodeIt) // for each dataNode
     {
       // add node to the node vector and to the combobox
       this->AddNode(nodeIt.Value().GetPointer());
     }
   }
 }
 
 void QmitkDataStorageComboBox::RemoveNodeAndPropertyLists(int index)
 {
   // remove itk::Event observer
   mitk::DataNode *dataNode = m_Nodes.at(index);
 
   // remove observer from data node property list
   mitk::PropertyList* dataNodePropertyList = dataNode->GetPropertyList();
   if (nullptr != dataNodePropertyList)
   {
     dataNodePropertyList->RemoveObserver(m_DataNodePropertyListObserverTags[index]);
     // remove observer tags from lists
     m_DataNodePropertyListObserverTags.erase(m_DataNodePropertyListObserverTags.begin() + index);
   }
 
   // remove observer from base data property list
   mitk::BaseData* baseData = dynamic_cast<mitk::BaseData*>(dataNode->GetData());
   if (nullptr != baseData)
   {
     mitk::PropertyList* baseDataPropertyList = baseData->GetPropertyList();
     if (nullptr != dataNodePropertyList)
     {
       baseDataPropertyList->RemoveObserver(m_BaseDatapropertyListObserverTags[index]);
       // remove observer tags from lists
       m_BaseDatapropertyListObserverTags.erase(m_BaseDatapropertyListObserverTags.begin() + index);
     }
   }
 
   // remove node from node vector
   m_Nodes.erase(m_Nodes.begin() + index);
 }
 
 void QmitkDataStorageComboBox::UpdateComboBoxText(const mitk::PropertyList* propertyList)
 {
   mitk::PropertyList* dataNodePropertyList = nullptr;
   mitk::PropertyList* baseDataPropertyList = nullptr;
   mitk::BaseData* baseData;
   for (const auto& node : m_Nodes)
   {
     dataNodePropertyList = node->GetPropertyList();
 
     baseData = dynamic_cast<mitk::BaseData*>(node->GetData());
     if (nullptr != baseData)
     {
       baseDataPropertyList = baseData->GetPropertyList();
     }
 
     if (propertyList == dataNodePropertyList
      || propertyList == baseDataPropertyList)
     {
       // if one of the property list is the one that has just been modified
       // get the node's index and set its text to the node name
       // the node name might have been changed, depending on the modified property list
       auto index = Find(node);
       // update text in combobox
       this->setItemText(index, QString::fromStdString(node->GetName()));
       return;
     }
   }
 }
diff --git a/Modules/QtWidgets/src/QmitkDataStorageDefaultListModel.cpp b/Modules/QtWidgets/src/QmitkDataStorageDefaultListModel.cpp
index dd134255e6..5613a76721 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageDefaultListModel.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageDefaultListModel.cpp
@@ -1,179 +1,175 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkDataStorageDefaultListModel.h>
 
 // qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 #include "QmitkNodeDescriptorManager.h"
 
 QmitkDataStorageDefaultListModel::QmitkDataStorageDefaultListModel(QObject *parent)
   : QmitkAbstractDataStorageModel(parent)
 {
 }
 
 void QmitkDataStorageDefaultListModel::DataStorageChanged()
 {
   UpdateModelData();
 }
 
 void QmitkDataStorageDefaultListModel::NodePredicateChanged()
 {
   UpdateModelData();
 }
 
 void QmitkDataStorageDefaultListModel::NodeAdded(const mitk::DataNode* /*node*/)
 {
   UpdateModelData();
 }
 
 void QmitkDataStorageDefaultListModel::NodeChanged(const mitk::DataNode* node)
 {
   // since the "NodeChanged" event is sent quite often, we check here, if it is relevant for this model
   if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node))
   {
     UpdateModelData();
     return;
   }
 
   // not relevant - need to check if we have to remove it
   if (std::find(m_DataNodes.begin(), m_DataNodes.end(), node) != m_DataNodes.end())
   {
     UpdateModelData();
   }
 }
 
 void QmitkDataStorageDefaultListModel::NodeRemoved(const mitk::DataNode* /*node*/)
 {
   UpdateModelData();
 }
 
 QModelIndex QmitkDataStorageDefaultListModel::index(int row, int column, const QModelIndex &parent) const
 {
   bool hasIndex = this->hasIndex(row, column, parent);
   if (hasIndex)
   {
     return this->createIndex(row, column);
   }
 
   return QModelIndex();
 }
 
 QModelIndex QmitkDataStorageDefaultListModel::parent(const QModelIndex &/*child*/) const
 {
   return QModelIndex();
 }
 
 int QmitkDataStorageDefaultListModel::rowCount(const QModelIndex &parent) const
 {
   if (parent.isValid())
   {
     return 0;
   }
 
   return m_DataNodes.size();
 }
 
 int QmitkDataStorageDefaultListModel::columnCount(const QModelIndex &parent) const
 {
   if (parent.isValid())
   {
     return 0;
   }
 
   return 1;
 }
 
 QVariant QmitkDataStorageDefaultListModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid() || index.model() != this)
   {
     return QVariant();
   }
 
   if(index.row() < 0 || index.row() >= static_cast<int>(m_DataNodes.size()))
   {
     return QVariant();
   }
 
   mitk::DataNode::Pointer dataNode = m_DataNodes.at(index.row());
   QString nodeName = QString::fromStdString(dataNode->GetName());
   if (nodeName.isEmpty())
     nodeName = "unnamed";
 
   if (role == Qt::DisplayRole)
     return nodeName;
   else if (role == Qt::ToolTipRole)
     return nodeName;
   else if (role == Qt::DecorationRole)
   {
     QmitkNodeDescriptor *nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
     return nodeDescriptor->GetIcon(dataNode);
   }
   else if (role == QmitkDataNodeRole)
   {
     return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
   }
   else if (role == QmitkDataNodeRawPointerRole)
   {
     return QVariant::fromValue<mitk::DataNode *>(dataNode);
   }
 
   return QVariant();
 }
 
 QVariant QmitkDataStorageDefaultListModel::headerData(int /*section*/, Qt::Orientation /*orientation*/, int /*role*/) const
 {
   return QVariant(tr("Nodes"));
 }
 
 Qt::ItemFlags QmitkDataStorageDefaultListModel::flags(const QModelIndex &index) const
 {
   if (index.isValid() && index.model() == this)
   {
     return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
   }
 
   return Qt::NoItemFlags;
 }
 
 void QmitkDataStorageDefaultListModel::UpdateModelData()
 {
   mitk::DataStorage::SetOfObjects::ConstPointer dataNodes;
-  if (!m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
-    if (dataStorage.IsNotNull() && m_NodePredicate.IsNotNull())
-    {
-      dataNodes = dataStorage->GetSubset(m_NodePredicate);
-    }
-    else
-    {
-      dataNodes = dataStorage->GetAll();
-    }
+    dataNodes = m_NodePredicate.IsNotNull()
+      ? dataStorage->GetSubset(m_NodePredicate)
+      : dataStorage->GetAll();
   }
 
   // update the model, so that it will be filled with the nodes of the new data storage
   beginResetModel();
   m_DataNodes.clear();
 
   // add all (filtered) nodes to the vector of nodes
   if (dataNodes != nullptr)
   {
     for (auto& node : *dataNodes)
     {
       m_DataNodes.push_back(node);
     }
   }
   endResetModel();
 }
diff --git a/Modules/QtWidgets/src/QmitkDataStorageHistoryModel.cpp b/Modules/QtWidgets/src/QmitkDataStorageHistoryModel.cpp
index c394e7cf83..a28ccce3d3 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageHistoryModel.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageHistoryModel.cpp
@@ -1,89 +1,80 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkDataStorageHistoryModel.h>
 
 #include "mitkWeakPointer.h"
 #include <deque>
 #include <algorithm>
 #include <mutex>
 
 /** Type of the internal history container.
  Remark: It stores raw pointer instead of mitk::WeakPointer
  because this lead to occasional crashes when the application was closed (see T24770 for a similar problem
  with the same reason*/
 using NodeHistoryType = std::deque< const mitk::DataNode* >;
 
 /** History of node selection. It is sorted from new to old.*/
 NodeHistoryType _nodeHistory;
 std::mutex _historyMutex;
 
 QmitkDataStorageHistoryModel::QmitkDataStorageHistoryModel(QObject *parent) : QmitkDataStorageDefaultListModel(parent)
 {
 }
 
 void QmitkDataStorageHistoryModel::UpdateModelData()
 {
     std::vector<mitk::DataNode::Pointer> dataNodes;
-    if (!m_DataStorage.IsExpired())
+    auto dataStorage = m_DataStorage.Lock();
+    if (dataStorage.IsNotNull())
     {
-        auto dataStorage = m_DataStorage.Lock();
-        if (dataStorage.IsNotNull())
+      auto nodesCandidats = m_NodePredicate.IsNotNull()
+        ? dataStorage->GetSubset(m_NodePredicate)
+        : dataStorage->GetAll();
+
+      const std::lock_guard<std::mutex> lock(_historyMutex);
+
+      for (auto historyNode : _nodeHistory)
+      {
+        auto finding = std::find(nodesCandidats->begin(), nodesCandidats->end(), historyNode);
+        if (finding != nodesCandidats->end())
         {
-          mitk::DataStorage::SetOfObjects::ConstPointer nodesCandidats;
-          if (m_NodePredicate.IsNotNull())
-          {
-            nodesCandidats = dataStorage->GetSubset(m_NodePredicate);
-          }
-          else
-          {
-            nodesCandidats = dataStorage->GetAll();
-          }
-
-          const std::lock_guard<std::mutex> lock(_historyMutex);
-
-          for (auto historyNode : _nodeHistory)
-          {
-            auto finding = std::find(nodesCandidats->begin(), nodesCandidats->end(), historyNode);
-            if (finding != nodesCandidats->end())
-            {
-              dataNodes.push_back(*finding);
-            }
-          }
+          dataNodes.push_back(*finding);
         }
+      }
     }
 
     // update the model, so that it will be filled with the nodes of the new data storage
     beginResetModel();
     m_DataNodes = dataNodes;
     endResetModel();
 }
 
 void QmitkDataStorageHistoryModel::AddNodeToHistory(mitk::DataNode* node)
 {
     const std::lock_guard<std::mutex> lock(_historyMutex);
 
     auto finding = std::find(std::begin(_nodeHistory), std::end(_nodeHistory), node);
     while (finding != std::end(_nodeHistory))
     {
         _nodeHistory.erase(finding);
         finding = std::find(std::begin(_nodeHistory), std::end(_nodeHistory), node);
     }
 
     _nodeHistory.push_front(node);
 }
 
 void QmitkDataStorageHistoryModel::ResetHistory()
 {
     const std::lock_guard<std::mutex> lock(_historyMutex);
     _nodeHistory.clear();
 }
diff --git a/Modules/QtWidgets/src/QmitkDataStorageSimpleTreeModel.cpp b/Modules/QtWidgets/src/QmitkDataStorageSimpleTreeModel.cpp
index b85cb7e2bd..5cc4153ab6 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageSimpleTreeModel.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageSimpleTreeModel.cpp
@@ -1,371 +1,375 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkDataStorageSimpleTreeModel.h>
 #include <QmitkDataStorageTreeModelInternalItem.h>
 #include <QmitkNodeDescriptorManager.h>
 
 // qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 
 QmitkDataStorageSimpleTreeModel::QmitkDataStorageSimpleTreeModel(QObject *parent)
   : QmitkAbstractDataStorageModel(parent)
   , m_Root(nullptr)
 {
   ResetTree();
 }
 
 QmitkDataStorageSimpleTreeModel::~QmitkDataStorageSimpleTreeModel()
 {
   m_Root->Delete();
   m_Root = nullptr;
 }
 
 void QmitkDataStorageSimpleTreeModel::ResetTree()
 {
   mitk::DataNode::Pointer rootDataNode = mitk::DataNode::New();
   rootDataNode->SetName("Data Storage");
   m_Root = new TreeItem(rootDataNode, nullptr);
 }
 
 void QmitkDataStorageSimpleTreeModel::DataStorageChanged()
 {
   if (m_Root)
   {
     m_Root->Delete();
   }
 
   beginResetModel();
   ResetTree();
   UpdateModelData();
   endResetModel();
 }
 
 void QmitkDataStorageSimpleTreeModel::NodePredicateChanged()
 {
   beginResetModel();
   ResetTree();
   UpdateModelData();
   endResetModel();
 }
 
 void QmitkDataStorageSimpleTreeModel::NodeAdded(const mitk::DataNode *node)
 {
-  if (node == nullptr || m_DataStorage.IsExpired() || !m_DataStorage.Lock()->Exists(node) ||
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (node == nullptr || dataStorage.IsNull() || !dataStorage->Exists(node) ||
       m_Root->Find(node) != nullptr)
     return;
 
   this->AddNodeInternal(node);
 }
 
 void QmitkDataStorageSimpleTreeModel::NodeChanged(const mitk::DataNode *node)
 {
   TreeItem *treeItem = m_Root->Find(node);
   if (treeItem)
   {
     TreeItem *parentTreeItem = treeItem->GetParent();
     // as the root node should not be removed one should always have a parent item
     if (!parentTreeItem)
       return;
     QModelIndex index = this->createIndex(treeItem->GetIndex(), 0, treeItem);
 
     // now emit the dataChanged signal
     emit dataChanged(index, index);
   }
 }
 
 void QmitkDataStorageSimpleTreeModel::NodeRemoved(const mitk::DataNode *node)
 {
   if (node == nullptr || !m_Root)
     return;
 
   TreeItem *treeItem = m_Root->Find(node);
   if (!treeItem)
     return; // return because there is no treeitem containing this node
 
   TreeItem *parentTreeItem = treeItem->GetParent();
   QModelIndex parentIndex = this->IndexFromTreeItem(parentTreeItem);
 
   // emit beginRemoveRows event (QModelIndex is empty because we dont have a tree model)
   this->beginRemoveRows(parentIndex, treeItem->GetIndex(), treeItem->GetIndex());
 
   // remove node
   std::vector<TreeItem *> children = treeItem->GetChildren();
   m_TreeItems.remove(treeItem);
   delete treeItem; //delete in tree
 
   if (!children.empty())
   {
     //if not empty we have to rebuild the whole representation,
     //because the children could be now top level, or at another
     //source/parent.
     this->UpdateModelData();
   }
 }
 
 QModelIndex QmitkDataStorageSimpleTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
   TreeItem *parentItem;
 
   if (!parent.isValid() || parent.model() != this)
     parentItem = m_Root;
   else
     parentItem = static_cast<TreeItem *>(parent.internalPointer());
 
   if (parentItem)
   {
     TreeItem *childItem = parentItem->GetChild(row);
     if (childItem)
       return createIndex(row, column, childItem);
   }
 
   return QModelIndex();
 }
 
 QModelIndex QmitkDataStorageSimpleTreeModel::parent(const QModelIndex &child) const
 {
   if (!child.isValid() || !m_Root || child.model() != this)
     return QModelIndex();
 
   TreeItem *childItem = this->TreeItemFromIndex(child);
 
   if (!childItem)
     return QModelIndex();
 
   TreeItem *parentItem = childItem->GetParent();
 
   if (parentItem == m_Root)
     return QModelIndex();
 
   return this->createIndex(parentItem->GetIndex(), 0, parentItem);
 }
 
 QmitkDataStorageSimpleTreeModel::TreeItem *QmitkDataStorageSimpleTreeModel::TreeItemFromIndex(
   const QModelIndex &index) const
 {
   if (index.isValid() && index.model() == this)
   {
     auto item = static_cast<TreeItem *>(index.internalPointer());
     auto finding = std::find(std::begin(m_TreeItems), std::end(m_TreeItems), item);
     if (finding == std::end(m_TreeItems))
     {
       return nullptr;
     }
     return item;
   }
   else
     return m_Root;
 }
 
 int QmitkDataStorageSimpleTreeModel::rowCount(const QModelIndex &parent) const
 {
   TreeItem *parentTreeItem = this->TreeItemFromIndex(parent);
   if (parentTreeItem)
     return parentTreeItem->GetChildCount();
   else
     return 0;
 }
 
 int QmitkDataStorageSimpleTreeModel::columnCount(const QModelIndex &/*parent*/) const
 {
   return 1;
 }
 
 QVariant QmitkDataStorageSimpleTreeModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid() || index.model() != this)
   {
     return QVariant();
   }
 
   auto treeItem = this->TreeItemFromIndex(index);
   if (!treeItem)
     return QVariant();
 
   mitk::DataNode *dataNode = treeItem->GetDataNode();
 
   QString nodeName = QString::fromStdString(dataNode->GetName());
   if (nodeName.isEmpty())
   {
     nodeName = "unnamed";
   }
 
   if (role == Qt::DisplayRole)
     return nodeName;
   else if (role == Qt::ToolTipRole)
     return nodeName;
   else if (role == Qt::DecorationRole)
   {
     QmitkNodeDescriptor *nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
     return nodeDescriptor->GetIcon(dataNode);
   }
   else if (role == QmitkDataNodeRole)
   {
     return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
   }
   else if (role == QmitkDataNodeRawPointerRole)
   {
     return QVariant::fromValue<mitk::DataNode *>(dataNode);
   }
 
   return QVariant();
 }
 
 bool QmitkDataStorageSimpleTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
   if (!index.isValid() || index.model() != this)
     return false;
 
   auto treeItem = this->TreeItemFromIndex(index);
   if (!treeItem)
     return false;
 
   mitk::DataNode *dataNode = treeItem->GetDataNode();
   if (!dataNode)
     return false;
 
   if (role == Qt::EditRole && !value.toString().isEmpty())
   {
     dataNode->SetName(value.toString().toStdString().c_str());
   }
   else if (role == Qt::CheckStateRole)
   {
     // Please note: value.toInt() returns 2, independentely from the actual checkstate of the index element.
     // Therefore the checkstate is being estimated again here.
 
     QVariant qcheckstate = index.data(Qt::CheckStateRole);
     int checkstate = qcheckstate.toInt();
     bool isVisible = bool(checkstate);
     dataNode->SetVisibility(!isVisible);
   }
   // inform listeners about changes
   emit dataChanged(index, index);
   return true;
 }
 
 QVariant QmitkDataStorageSimpleTreeModel::headerData(int /*section*/, Qt::Orientation orientation, int role) const
 {
   if (orientation == Qt::Horizontal && role == Qt::DisplayRole && m_Root)
     return QString::fromStdString(m_Root->GetDataNode()->GetName());
 
   return QVariant();
 }
 
 Qt::ItemFlags QmitkDataStorageSimpleTreeModel::flags(const QModelIndex &index) const
 {
   if (index.isValid() && index.model() == this)
   {
     auto treeItem = this->TreeItemFromIndex(index);
     if (!treeItem)
       return Qt::NoItemFlags;
 
     const auto dataNode = treeItem->GetDataNode();
     if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(dataNode))
     {
       return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
     }
     else
     {
       return Qt::NoItemFlags;
     }
 
   }
 
   return Qt::NoItemFlags;
 }
 
 mitk::DataNode *QmitkDataStorageSimpleTreeModel::GetParentNode(const mitk::DataNode *node) const
 {
   mitk::DataNode *dataNode = nullptr;
 
   mitk::DataStorage::SetOfObjects::ConstPointer _Sources = m_DataStorage.Lock()->GetSources(node);
 
   if (_Sources->Size() > 0)
     dataNode = _Sources->front();
 
   return dataNode;
 }
 
 void QmitkDataStorageSimpleTreeModel::AddNodeInternal(const mitk::DataNode *node)
 {
-  if (node == nullptr || m_DataStorage.IsExpired() || !m_DataStorage.Lock()->Exists(node) || m_Root->Find(node) != nullptr)
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (node == nullptr || dataStorage.IsNull() || !dataStorage->Exists(node) || m_Root->Find(node) != nullptr)
     return;
 
   // find out if we have a root node
   TreeItem *parentTreeItem = m_Root;
   QModelIndex index;
   mitk::DataNode *parentDataNode = this->GetParentNode(node);
 
   if (parentDataNode) // no top level data node
   {
     parentTreeItem = m_Root->Find(parentDataNode); // find the corresponding tree item
     if (!parentTreeItem)
     {
       this->NodeAdded(parentDataNode);
       parentTreeItem = m_Root->Find(parentDataNode);
       if (!parentTreeItem)
         return;
     }
 
     // get the index of this parent with the help of the grand parent
     index = this->createIndex(parentTreeItem->GetIndex(), 0, parentTreeItem);
   }
 
   int firstRowWithASiblingBelow = 0;
   int nodeLayer = -1;
   node->GetIntProperty("layer", nodeLayer);
   for (TreeItem *siblingTreeItem : parentTreeItem->GetChildren())
   {
     int siblingLayer = -1;
     if (mitk::DataNode *siblingNode = siblingTreeItem->GetDataNode())
     {
       siblingNode->GetIntProperty("layer", siblingLayer);
     }
     if (nodeLayer > siblingLayer)
     {
       break;
     }
     ++firstRowWithASiblingBelow;
   }
   beginInsertRows(index, firstRowWithASiblingBelow, firstRowWithASiblingBelow);
   auto newNode = new TreeItem(const_cast<mitk::DataNode *>(node));
   parentTreeItem->InsertChild(newNode, firstRowWithASiblingBelow);
   m_TreeItems.push_back(newNode);
 
   endInsertRows();
 }
 
 QModelIndex QmitkDataStorageSimpleTreeModel::IndexFromTreeItem(TreeItem *item) const
 {
   if (item == m_Root)
     return QModelIndex();
   else
     return this->createIndex(item->GetIndex(), 0, item);
 }
 
 void QmitkDataStorageSimpleTreeModel::UpdateModelData()
 {
-  if (!m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNotNull())
   {
-    auto nodeset = m_DataStorage.Lock()->GetAll();
-    if (m_NodePredicate != nullptr)
-    {
-      nodeset = m_DataStorage.Lock()->GetSubset(m_NodePredicate);
-    }
+    auto nodeset = m_NodePredicate != nullptr
+      ? dataStorage->GetSubset(m_NodePredicate)
+      : dataStorage->GetAll();
 
     for (const auto& node : *nodeset)
     {
       this->AddNodeInternal(node);
     }
   }
 }
diff --git a/Modules/QtWidgets/src/QmitkDataStorageTableModel.cpp b/Modules/QtWidgets/src/QmitkDataStorageTableModel.cpp
index 96884c3dff..a877e2f8ee 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageTableModel.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageTableModel.cpp
@@ -1,516 +1,509 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkDataStorageTableModel.h"
 
 //# Own includes
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 #include "mitkNodePredicateBase.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include <QmitkNodeDescriptorManager.h>
 
 //# Toolkit includes
 #include <QFile>
 #include <QIcon>
 #include <itkCommand.h>
 
 //#CTORS/DTOR
 QmitkDataStorageTableModel::QmitkDataStorageTableModel(mitk::DataStorage::Pointer _DataStorage,
                                                        mitk::NodePredicateBase *_Predicate,
                                                        QObject *parent)
   : QAbstractTableModel(parent),
     m_DataStorage(nullptr),
     m_Predicate(nullptr),
     m_BlockEvents(false),
     m_SortDescending(false)
 {
   this->SetPredicate(_Predicate);
   this->SetDataStorage(_DataStorage);
 }
 
 QmitkDataStorageTableModel::~QmitkDataStorageTableModel()
 {
   // set data storage 0 to remove event listeners
   this->SetDataStorage(nullptr);
 }
 
 //# Public GETTER
 const mitk::DataStorage::Pointer QmitkDataStorageTableModel::GetDataStorage() const
 {
   return m_DataStorage.Lock();
 }
 
 mitk::NodePredicateBase::Pointer QmitkDataStorageTableModel::GetPredicate() const
 {
   return m_Predicate;
 }
 
 mitk::DataNode::Pointer QmitkDataStorageTableModel::GetNode(const QModelIndex &index) const
 {
   mitk::DataNode::Pointer node;
 
   if (index.isValid())
   {
     node = m_NodeSet.at(index.row());
   }
 
   return node;
 }
 
 QVariant QmitkDataStorageTableModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   QVariant headerData;
 
   // show only horizontal header
   if (role == Qt::DisplayRole)
   {
     if (orientation == Qt::Horizontal)
     {
       // first column: "Name"
       if (section == 0)
         headerData = "Name";
       else if (section == 1)
         headerData = "Data Type";
       else if (section == 2)
         headerData = "Visibility";
     }
     else if (orientation == Qt::Vertical)
     {
       // show numbers for rows
       headerData = section + 1;
     }
   }
 
   return headerData;
 }
 
 Qt::ItemFlags QmitkDataStorageTableModel::flags(const QModelIndex &index) const
 {
   Qt::ItemFlags flags = QAbstractItemModel::flags(index);
 
   // name & visibility is editable
   if (index.column() == 0)
   {
     flags |= Qt::ItemIsEditable;
   }
   else if (index.column() == 2)
   {
     flags |= Qt::ItemIsUserCheckable;
   }
 
   return flags;
 }
 
 int QmitkDataStorageTableModel::rowCount(const QModelIndex &) const
 {
   return m_NodeSet.size();
 }
 
 int QmitkDataStorageTableModel::columnCount(const QModelIndex &) const
 {
   // show name, type and visible columnn
   int columns = 3;
   return columns;
 }
 
 QVariant QmitkDataStorageTableModel::data(const QModelIndex &index, int role) const
 {
   QVariant data;
 
   if (index.isValid() && !m_NodeSet.empty())
   {
     mitk::DataNode::Pointer node = m_NodeSet.at(index.row());
 
     std::string nodeName = node->GetName();
     if (nodeName.empty())
       nodeName = "unnamed";
 
     // get name
     if (index.column() == 0)
     {
       // get name of node (may also be edited)
       if (role == Qt::DisplayRole || role == Qt::EditRole)
       {
         data = QString::fromStdString(nodeName);
       }
       else if (role == QmitkDataNodeRole)
       {
         data = QVariant::fromValue(node);
       }
     }
     else if (index.column() == 1)
     {
       QmitkNodeDescriptor *nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(node);
 
       // get type property of mitk::BaseData
       if (role == Qt::DisplayRole)
       {
         data = nodeDescriptor->GetNameOfClass();
       }
       // show some nice icons for datatype
       else if (role == Qt::DecorationRole)
       {
         data = nodeDescriptor->GetIcon(node);
       }
     }
     else if (index.column() == 2)
     {
       // get visible property of mitk::BaseData
       bool visibility = false;
 
       if (node->GetVisibility(visibility, nullptr) && role == Qt::CheckStateRole)
       {
         data = (visibility ? Qt::Checked : Qt::Unchecked);
       } // node->GetVisibility(visibility, 0) && role == Qt::CheckStateRole
 
     } // index.column() == 2
 
   } // index.isValid() && !m_NodeSet.empty()
   return data;
 }
 
 //# Public SETTERS
 void QmitkDataStorageTableModel::SetPredicate(mitk::NodePredicateBase *_Predicate)
 {
   // ensure that a new predicate is set in order to avoid unnecessary changed events
   if (m_Predicate != _Predicate)
   {
     m_Predicate = _Predicate;
     this->Reset();
   }
 }
 
 void QmitkDataStorageTableModel::SetDataStorage(mitk::DataStorage::Pointer _DataStorage)
 {
   // only proceed if we have a new datastorage
   if (m_DataStorage != _DataStorage)
   {
+    auto dataStorage = m_DataStorage.Lock();
+
     // if a data storage was set before remove old event listeners
-    if (!m_DataStorage.IsExpired())
+    if (dataStorage.IsNotNull())
     {
-      auto dataStorage = m_DataStorage.Lock();
-
       dataStorage->AddNodeEvent.RemoveListener(
         mitk::MessageDelegate1<QmitkDataStorageTableModel, const mitk::DataNode *>(
           this, &QmitkDataStorageTableModel::AddNode));
 
       dataStorage->RemoveNodeEvent.RemoveListener(
         mitk::MessageDelegate1<QmitkDataStorageTableModel, const mitk::DataNode *>(
           this, &QmitkDataStorageTableModel::RemoveNode));
     }
 
     // set new data storage
     m_DataStorage = _DataStorage;
+    dataStorage = m_DataStorage.Lock();
 
     // if new storage is not 0 subscribe for events
-    if (!m_DataStorage.IsExpired())
+    if (dataStorage.IsNotNull())
     {
-      auto dataStorage = m_DataStorage.Lock();
-
       // subscribe for node added/removed events
       dataStorage->AddNodeEvent.AddListener(
         mitk::MessageDelegate1<QmitkDataStorageTableModel, const mitk::DataNode *>(
           this, &QmitkDataStorageTableModel::AddNode));
 
       dataStorage->RemoveNodeEvent.AddListener(
         mitk::MessageDelegate1<QmitkDataStorageTableModel, const mitk::DataNode *>(
           this, &QmitkDataStorageTableModel::RemoveNode));
     }
 
     // Reset model (even if datastorage is 0->will be checked in Reset())
     this->Reset();
   }
 }
 
 void QmitkDataStorageTableModel::AddNode(const mitk::DataNode *node)
 {
   // garantuee no recursions when a new node event is thrown
   if (!m_BlockEvents)
   {
     // if we have a predicate, check node against predicate first
     if (m_Predicate.IsNotNull() && !m_Predicate->CheckNode(node))
       return;
 
     // dont add nodes without data (formerly known as helper objects)
     if (node->GetData() == nullptr)
       return;
 
     // create listener commands to listen to changes in the name or the visibility of the node
     itk::MemberCommand<QmitkDataStorageTableModel>::Pointer propertyModifiedCommand =
       itk::MemberCommand<QmitkDataStorageTableModel>::New();
     propertyModifiedCommand->SetCallbackFunction(this, &QmitkDataStorageTableModel::PropertyModified);
 
     mitk::BaseProperty *tempProperty = nullptr;
 
     // add listener for properties
     tempProperty = node->GetProperty("visible");
     if (tempProperty)
       m_VisiblePropertyModifiedObserverTags[tempProperty] =
         tempProperty->AddObserver(itk::ModifiedEvent(), propertyModifiedCommand);
 
     tempProperty = node->GetProperty("name");
     if (tempProperty)
       m_NamePropertyModifiedObserverTags[tempProperty] =
         tempProperty->AddObserver(itk::ModifiedEvent(), propertyModifiedCommand);
 
     // emit beginInsertRows event
     beginInsertRows(QModelIndex(), m_NodeSet.size(), m_NodeSet.size());
 
     // add node
     m_NodeSet.push_back(const_cast<mitk::DataNode *>(node));
 
     // emit endInsertRows event
     endInsertRows();
   }
 }
 
 void QmitkDataStorageTableModel::RemoveNode(const mitk::DataNode *node)
 {
   // garantuee no recursions when a new node event is thrown
   if (!m_BlockEvents)
   {
     // find corresponding node
     auto nodeIt = std::find(m_NodeSet.begin(), m_NodeSet.end(), node);
 
     if (nodeIt != m_NodeSet.end())
     {
       // now: remove listeners for name property ...
       mitk::BaseProperty *tempProperty = nullptr;
 
       tempProperty = (*nodeIt)->GetProperty("visible");
       if (tempProperty)
         tempProperty->RemoveObserver(m_VisiblePropertyModifiedObserverTags[tempProperty]);
       m_VisiblePropertyModifiedObserverTags.erase(tempProperty);
 
       // ... and visibility property
       tempProperty = (*nodeIt)->GetProperty("name");
       if (tempProperty)
         tempProperty->RemoveObserver(m_NamePropertyModifiedObserverTags[tempProperty]);
       m_NamePropertyModifiedObserverTags.erase(tempProperty);
 
       // get an index from iterator
       int row = std::distance(m_NodeSet.begin(), nodeIt);
 
       // emit beginRemoveRows event (QModelIndex is empty because we dont have a tree model)
       this->beginRemoveRows(QModelIndex(), row, row);
 
       // remove node
       m_NodeSet.erase(nodeIt);
 
       // emit endRemoveRows event
       endRemoveRows();
     }
   }
 }
 
 void QmitkDataStorageTableModel::PropertyModified(const itk::Object *caller, const itk::EventObject &)
 {
   if (!m_BlockEvents)
   {
     // get modified property
     const mitk::BaseProperty *modifiedProperty = dynamic_cast<const mitk::BaseProperty *>(caller);
 
     if (modifiedProperty)
     {
       // find node that holds the modified property
       int row = -1;
       int column = -1;
 
       std::vector<mitk::DataNode *>::iterator it;
       mitk::BaseProperty *visibilityProperty = nullptr;
       mitk::BaseProperty *nameProperty = nullptr;
 
       // search for property that changed and emit datachanged on the corresponding ModelIndex
       for (it = m_NodeSet.begin(); it != m_NodeSet.end(); it++)
       {
         // check for the visible property or the name property
         visibilityProperty = (*it)->GetProperty("visible");
         if (modifiedProperty == visibilityProperty)
         {
           column = 2;
           break;
         }
 
         nameProperty = (*it)->GetProperty("name");
         if (modifiedProperty == nameProperty)
         {
           column = 0;
           break;
         }
       }
 
       // if we have the property we have a valid iterator
       if (it != m_NodeSet.end())
         row = std::distance(m_NodeSet.begin(), it);
 
       // now emit the dataChanged signal
       QModelIndex indexOfChangedProperty = index(row, column);
       emit dataChanged(indexOfChangedProperty, indexOfChangedProperty);
     }
   }
 }
 
 bool QmitkDataStorageTableModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
   bool noErr = false;
 
   if (index.isValid() && (role == Qt::EditRole || role == Qt::CheckStateRole))
   {
     // any change events produced here should not be caught in this class
     // --> set m_BlockEvents to true
     m_BlockEvents = true;
 
     mitk::DataNode::Pointer node = m_NodeSet.at(index.row());
 
     if (index.column() == 0)
     {
       node->SetStringProperty("name", value.toString().toStdString().c_str());
     }
     else if (index.column() == 2)
     {
       node->SetBoolProperty("visible", (value.toInt() == Qt::Checked ? true : false));
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     // inform listeners about changes
     emit dataChanged(index, index);
 
     m_BlockEvents = false;
     noErr = true;
   }
 
   return noErr;
 }
 
 //#Protected SETTER
 void QmitkDataStorageTableModel::Reset()
 {
   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet;
 
   // remove all nodes now (dont use iterators because removing elements
   // would invalidate the iterator)
   // start at the last element: first in, last out
   unsigned int i = m_NodeSet.size();
   while (!m_NodeSet.empty())
   {
     --i;
     this->RemoveNode(m_NodeSet.at(i));
   }
 
   // normally now everything should be empty->just to be sure
   // erase all arrays again
   m_NamePropertyModifiedObserverTags.clear();
   m_VisiblePropertyModifiedObserverTags.clear();
   m_NodeSet.clear();
 
+  auto dataStorage = m_DataStorage.Lock();
+
   // the whole reset depends on the fact if a data storage is set or not
-  if (!m_DataStorage.IsExpired())
+  if (dataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
-
-    if (m_Predicate.IsNotNull())
-      // get subset
-      _NodeSet = dataStorage->GetSubset(m_Predicate);
-    // if predicate is nullptr, select all nodes
-    else
-    {
-      _NodeSet = dataStorage->GetAll();
-      // remove ghost root node
-    }
+    _NodeSet = m_Predicate.IsNotNull()
+      ? dataStorage->GetSubset(m_Predicate)
+      : dataStorage->GetAll();
 
     // finally add all nodes to the model
     for (auto it = _NodeSet->begin(); it != _NodeSet->end(); it++)
     {
       // save node
       this->AddNode(*it);
     }
   }
 }
 
 void QmitkDataStorageTableModel::sort(int column, Qt::SortOrder order /*= Qt::AscendingOrder */)
 {
   bool sortDescending = (order == Qt::DescendingOrder) ? true : false;
 
   // do not sort twice !!! (dont know why, but qt calls this func twice. STUPID!)
   /*
     if(sortDescending != m_SortDescending)
     {*/
 
   // m_SortDescending = sortDescending;
 
   DataNodeCompareFunction::CompareCriteria _CompareCriteria = DataNodeCompareFunction::CompareByName;
 
   DataNodeCompareFunction::CompareOperator _CompareOperator =
     sortDescending ? DataNodeCompareFunction::Greater : DataNodeCompareFunction::Less;
 
   if (column == 1)
     _CompareCriteria = DataNodeCompareFunction::CompareByClassName;
 
   else if (column == 2)
     _CompareCriteria = DataNodeCompareFunction::CompareByVisibility;
 
   DataNodeCompareFunction compareFunc(_CompareCriteria, _CompareOperator);
   std::sort(m_NodeSet.begin(), m_NodeSet.end(), compareFunc);
 
   QAbstractTableModel::beginResetModel();
   QAbstractTableModel::endResetModel();
   //}
 }
 
 std::vector<mitk::DataNode *> QmitkDataStorageTableModel::GetNodeSet() const
 {
   return m_NodeSet;
 }
 
 QmitkDataStorageTableModel::DataNodeCompareFunction::DataNodeCompareFunction(CompareCriteria _CompareCriteria,
                                                                              CompareOperator _CompareOperator)
   : m_CompareCriteria(_CompareCriteria), m_CompareOperator(_CompareOperator)
 {
 }
 
 bool QmitkDataStorageTableModel::DataNodeCompareFunction::operator()(const mitk::DataNode::Pointer &_Left,
                                                                      const mitk::DataNode::Pointer &_Right) const
 {
   switch (m_CompareCriteria)
   {
     case CompareByClassName:
       if (m_CompareOperator == Less)
         return (_Left->GetData()->GetNameOfClass() < _Right->GetData()->GetNameOfClass());
       else
         return (_Left->GetData()->GetNameOfClass() > _Right->GetData()->GetNameOfClass());
       break;
 
     case CompareByVisibility:
     {
       bool _LeftVisibility = false;
       bool _RightVisibility = false;
       _Left->GetVisibility(_LeftVisibility, nullptr);
       _Right->GetVisibility(_RightVisibility, nullptr);
 
       if (m_CompareOperator == Less)
         return (_LeftVisibility < _RightVisibility);
       else
         return (_LeftVisibility > _RightVisibility);
     }
     break;
 
     // CompareByName:
     default:
       if (m_CompareOperator == Less)
         return (_Left->GetName() < _Right->GetName());
       else
         return (_Left->GetName() > _Right->GetName());
       break;
   }
 }
diff --git a/Modules/QtWidgets/src/QmitkDataStorageTreeModel.cpp b/Modules/QtWidgets/src/QmitkDataStorageTreeModel.cpp
index 2ab4f4d8be..c9e6644716 100644
--- a/Modules/QtWidgets/src/QmitkDataStorageTreeModel.cpp
+++ b/Modules/QtWidgets/src/QmitkDataStorageTreeModel.cpp
@@ -1,880 +1,884 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateData.h>
 #include <mitkNodePredicateFirstLevel.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkPlanarFigure.h>
 #include <mitkProperties.h>
 #include <mitkRenderingManager.h>
 #include <mitkStringProperty.h>
 
 #include <mitkPropertyNameHelper.h>
 
 #include "QmitkDataStorageTreeModel.h"
 #include "QmitkDataStorageTreeModelInternalItem.h"
 #include "QmitkNodeDescriptorManager.h"
 #include <QmitkCustomVariants.h>
 #include <QmitkEnums.h>
 #include <QmitkMimeTypes.h>
 
 #include <QFile>
 #include <QIcon>
 #include <QMimeData>
 #include <QTextStream>
 
 #include <map>
 
 #include <mitkCoreServices.h>
 
 QmitkDataStorageTreeModel::QmitkDataStorageTreeModel(mitk::DataStorage *_DataStorage,
                                                      bool _PlaceNewNodesOnTop,
                                                      QObject *parent)
   : QAbstractItemModel(parent),
     m_DataStorage(nullptr),
     m_PlaceNewNodesOnTop(_PlaceNewNodesOnTop),
     m_Root(nullptr),
     m_BlockDataStorageEvents(false),
     m_AllowHierarchyChange(false)
 {
   this->SetDataStorage(_DataStorage);
 }
 
 QmitkDataStorageTreeModel::~QmitkDataStorageTreeModel()
 {
   // set data storage to 0 = remove all listeners
   this->SetDataStorage(nullptr);
   m_Root->Delete();
   m_Root = nullptr;
 }
 
 mitk::DataNode::Pointer QmitkDataStorageTreeModel::GetNode(const QModelIndex &index) const
 {
   return this->TreeItemFromIndex(index)->GetDataNode();
 }
 
 const mitk::DataStorage::Pointer QmitkDataStorageTreeModel::GetDataStorage() const
 {
   return m_DataStorage.Lock();
 }
 
 QModelIndex QmitkDataStorageTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
   TreeItem *parentItem;
 
   if (!parent.isValid())
     parentItem = m_Root;
   else
     parentItem = static_cast<TreeItem *>(parent.internalPointer());
 
   TreeItem *childItem = parentItem->GetChild(row);
   if (childItem)
     return createIndex(row, column, childItem);
   else
     return QModelIndex();
 }
 
 int QmitkDataStorageTreeModel::rowCount(const QModelIndex &parent) const
 {
   TreeItem *parentTreeItem = this->TreeItemFromIndex(parent);
   return parentTreeItem->GetChildCount();
 }
 
 Qt::ItemFlags QmitkDataStorageTreeModel::flags(const QModelIndex &index) const
 {
   if (index.isValid())
   {
     return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable |
            Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
   }
   else
   {
     return Qt::ItemIsDropEnabled;
   }
 }
 
 int QmitkDataStorageTreeModel::columnCount(const QModelIndex & /* parent = QModelIndex() */) const
 {
   return 1;
 }
 
 QModelIndex QmitkDataStorageTreeModel::parent(const QModelIndex &index) const
 {
   if (!index.isValid())
     return QModelIndex();
 
   TreeItem *childItem = this->TreeItemFromIndex(index);
   TreeItem *parentItem = childItem->GetParent();
 
   if (parentItem == m_Root)
     return QModelIndex();
 
   return this->createIndex(parentItem->GetIndex(), 0, parentItem);
 }
 
 QmitkDataStorageTreeModel::TreeItem *QmitkDataStorageTreeModel::TreeItemFromIndex(const QModelIndex &index) const
 {
   if (index.isValid())
     return static_cast<TreeItem *>(index.internalPointer());
   else
     return m_Root;
 }
 Qt::DropActions QmitkDataStorageTreeModel::supportedDropActions() const
 {
   return Qt::CopyAction | Qt::MoveAction;
 }
 
 Qt::DropActions QmitkDataStorageTreeModel::supportedDragActions() const
 {
   return Qt::CopyAction | Qt::MoveAction;
 }
 
 bool QmitkDataStorageTreeModel::dropMimeData(
   const QMimeData *data, Qt::DropAction action, int row, int /*column*/, const QModelIndex &parent)
 {
   // Early exit, returning true, but not actually doing anything (ignoring data).
   if (action == Qt::IgnoreAction)
   {
     return true;
   }
 
   // Note, we are returning true if we handled it, and false otherwise
   bool returnValue = false;
 
   if (data->hasFormat("application/x-qabstractitemmodeldatalist"))
   {
     returnValue = true;
 
     // First we extract a Qlist of TreeItem* pointers.
     QList<TreeItem *> listOfItemsToDrop = ToTreeItemPtrList(data);
     if (listOfItemsToDrop.empty())
     {
       return false;
     }
 
     // Retrieve the TreeItem* where we are dropping stuff, and its parent.
     TreeItem *dropItem = this->TreeItemFromIndex(parent);
     TreeItem *parentItem = dropItem->GetParent();
 
     // If item was dropped onto empty space, we select the root node
     if (dropItem == m_Root)
     {
       parentItem = m_Root;
     }
 
     // Dragging and Dropping is only allowed within the same parent, so use the first item in list to validate.
     // (otherwise, you could have a derived image such as a segmentation, and assign it to another image).
     // NOTE: We are assuming the input list is valid... i.e. when it was dragged, all the items had the same parent.
 
     // Determine whether or not the drag and drop operation is a valid one.
     // Examples of invalid operations include:
     //  - dragging nodes with different parents
     //  - dragging nodes from one parent to another parent, if m_AllowHierarchyChange is false
     //  - dragging a node on one of its child nodes (only relevant if m_AllowHierarchyChange is true)
 
     bool isValidDragAndDropOperation(true);
 
     // different parents
     {
       TreeItem *firstParent = listOfItemsToDrop[0]->GetParent();
       QList<TreeItem *>::iterator diIter;
       for (diIter = listOfItemsToDrop.begin() + 1; diIter != listOfItemsToDrop.end(); diIter++)
       {
         if (firstParent != (*diIter)->GetParent())
         {
           isValidDragAndDropOperation = false;
           break;
         }
       }
     }
 
     // dragging from one parent to another
     if ((!m_AllowHierarchyChange) && isValidDragAndDropOperation)
     {
       if (row == -1) // drag onto a node
       {
         isValidDragAndDropOperation = listOfItemsToDrop[0]->GetParent() == parentItem;
       }
       else // drag between nodes
       {
         isValidDragAndDropOperation = listOfItemsToDrop[0]->GetParent() == dropItem;
       }
     }
 
     // dragging on a child node of one the dragged nodes
     {
       QList<TreeItem *>::iterator diIter;
       for (diIter = listOfItemsToDrop.begin(); diIter != listOfItemsToDrop.end(); diIter++)
       {
         TreeItem *tempItem = dropItem;
 
         while (tempItem != m_Root)
         {
           tempItem = tempItem->GetParent();
           if (tempItem == *diIter)
           {
             isValidDragAndDropOperation = false;
           }
         }
       }
     }
 
     if (!isValidDragAndDropOperation)
       return isValidDragAndDropOperation;
 
     if (listOfItemsToDrop[0] != dropItem && isValidDragAndDropOperation)
     {
       // Retrieve the index of where we are dropping stuff.
       QModelIndex parentModelIndex = this->IndexFromTreeItem(parentItem);
 
       int dragIndex = 0;
 
       // Iterate through the list of TreeItem (which may be at non-consecutive indexes).
       QList<TreeItem *>::iterator diIter;
       for (diIter = listOfItemsToDrop.begin(); diIter != listOfItemsToDrop.end(); diIter++)
       {
         TreeItem *itemToDrop = *diIter;
 
         // if the item is dragged down we have to compensate its final position for the
         // fact it is deleted lateron, this only applies if it is dragged within the same level
         if ((itemToDrop->GetIndex() < row) && (itemToDrop->GetParent() == dropItem))
         {
           dragIndex = 1;
         }
 
         // Here we assume that as you remove items, one at a time, that GetIndex() will be valid.
         this->beginRemoveRows(
           this->IndexFromTreeItem(itemToDrop->GetParent()), itemToDrop->GetIndex(), itemToDrop->GetIndex());
         itemToDrop->GetParent()->RemoveChild(itemToDrop);
         this->endRemoveRows();
       }
 
       // row = -1 dropped on an item, row != -1 dropped  in between two items
       // Select the target index position, or put it at the end of the list.
       int dropIndex = 0;
       if (row != -1)
       {
         if (dragIndex == 0)
           dropIndex = std::min(row, parentItem->GetChildCount() - 1);
         else
           dropIndex = std::min(row - 1, parentItem->GetChildCount() - 1);
       }
       else
       {
         dropIndex = dropItem->GetIndex();
       }
 
       QModelIndex dropItemModelIndex = this->IndexFromTreeItem(dropItem);
       if ((row == -1 && dropItemModelIndex.row() == -1) || dropItemModelIndex.row() > parentItem->GetChildCount())
         dropIndex = parentItem->GetChildCount() - 1;
 
       // Now insert items again at the drop item position
 
       if (m_AllowHierarchyChange)
       {
         this->beginInsertRows(dropItemModelIndex, dropIndex, dropIndex + listOfItemsToDrop.size() - 1);
       }
       else
       {
         this->beginInsertRows(parentModelIndex, dropIndex, dropIndex + listOfItemsToDrop.size() - 1);
       }
 
       for (diIter = listOfItemsToDrop.begin(); diIter != listOfItemsToDrop.end(); diIter++)
       {
         // dropped on node, behaviour depends on preference setting
         if (m_AllowHierarchyChange)
         {
           auto dataStorage = m_DataStorage.Lock();
 
           m_BlockDataStorageEvents = true;
           mitk::DataNode::Pointer droppedNode = (*diIter)->GetDataNode();
           mitk::DataNode *dropOntoNode = dropItem->GetDataNode();
           dataStorage->Remove(droppedNode);
           dataStorage->Add(droppedNode, dropOntoNode);
           m_BlockDataStorageEvents = false;
 
           dropItem->InsertChild((*diIter), dropIndex);
         }
         else
         {
           if (row == -1) // drag onto a node
           {
             parentItem->InsertChild((*diIter), dropIndex);
           }
           else // drag between nodes
           {
             dropItem->InsertChild((*diIter), dropIndex);
           }
         }
 
         dropIndex++;
       }
       this->endInsertRows();
 
       // Change Layers to match.
       this->AdjustLayerProperty();
     }
   }
   else if (data->hasFormat("application/x-mitk-datanodes"))
   {
     returnValue = true;
 
     int numberOfNodesDropped = 0;
 
     QList<mitk::DataNode *> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(data);
     mitk::DataNode *node = nullptr;
     foreach (node, dataNodeList)
     {
       auto datastorage = m_DataStorage.Lock();
       if (node && datastorage.IsNotNull() && !datastorage->Exists(node))
       {
         m_DataStorage.Lock()->Add(node);
         mitk::BaseData::Pointer basedata = node->GetData();
 
         if (basedata.IsNotNull())
         {
           mitk::RenderingManager::GetInstance()->InitializeViews(basedata->GetTimeGeometry());
 
           numberOfNodesDropped++;
         }
       }
     }
     // Only do a rendering update, if we actually dropped anything.
     if (numberOfNodesDropped > 0)
     {
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 
   return returnValue;
 }
 
 QStringList QmitkDataStorageTreeModel::mimeTypes() const
 {
   QStringList types = QAbstractItemModel::mimeTypes();
   types << "application/x-qabstractitemmodeldatalist";
   types << "application/x-mitk-datanodes";
   return types;
 }
 
 QMimeData *QmitkDataStorageTreeModel::mimeData(const QModelIndexList &indexes) const
 {
   return mimeDataFromModelIndexList(indexes);
 }
 
 QMimeData *QmitkDataStorageTreeModel::mimeDataFromModelIndexList(const QModelIndexList &indexes)
 {
   QMimeData *ret = new QMimeData;
 
   QString treeItemAddresses("");
   QString dataNodeAddresses("");
 
   QByteArray baTreeItemPtrs;
   QByteArray baDataNodePtrs;
 
   QDataStream dsTreeItemPtrs(&baTreeItemPtrs, QIODevice::WriteOnly);
   QDataStream dsDataNodePtrs(&baDataNodePtrs, QIODevice::WriteOnly);
 
   for (int i = 0; i < indexes.size(); i++)
   {
     TreeItem *treeItem = static_cast<TreeItem *>(indexes.at(i).internalPointer());
 
     dsTreeItemPtrs << reinterpret_cast<quintptr>(treeItem);
     dsDataNodePtrs << reinterpret_cast<quintptr>(treeItem->GetDataNode().GetPointer());
 
     // --------------- deprecated -----------------
     unsigned long long treeItemAddress = reinterpret_cast<unsigned long long>(treeItem);
     unsigned long long dataNodeAddress = reinterpret_cast<unsigned long long>(treeItem->GetDataNode().GetPointer());
     QTextStream(&treeItemAddresses) << treeItemAddress;
     QTextStream(&dataNodeAddresses) << dataNodeAddress;
 
     if (i != indexes.size() - 1)
     {
       QTextStream(&treeItemAddresses) << ",";
       QTextStream(&dataNodeAddresses) << ",";
     }
     // -------------- end deprecated -------------
   }
 
   // ------------------ deprecated -----------------
   ret->setData("application/x-qabstractitemmodeldatalist", QByteArray(treeItemAddresses.toLatin1()));
   ret->setData("application/x-mitk-datanodes", QByteArray(dataNodeAddresses.toLatin1()));
   // --------------- end deprecated -----------------
 
   ret->setData(QmitkMimeTypes::DataStorageTreeItemPtrs, baTreeItemPtrs);
   ret->setData(QmitkMimeTypes::DataNodePtrs, baDataNodePtrs);
 
   return ret;
 }
 
 QVariant QmitkDataStorageTreeModel::data(const QModelIndex &index, int role) const
 {
   mitk::DataNode *dataNode = this->TreeItemFromIndex(index)->GetDataNode();
 
   // get name of treeItem (may also be edited)
   QString nodeName = QString::fromStdString(dataNode->GetName());
   if (nodeName.isEmpty())
   {
     nodeName = "unnamed";
   }
 
   if (role == Qt::DisplayRole)
     return nodeName;
   else if (role == Qt::ToolTipRole)
     return nodeName;
   else if (role == Qt::DecorationRole)
   {
     QmitkNodeDescriptor *nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
     return nodeDescriptor->GetIcon(dataNode);
   }
   else if (role == Qt::CheckStateRole)
   {
     return dataNode->IsVisible(nullptr);
   }
   else if (role == QmitkDataNodeRole)
   {
     return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
   }
   else if (role == QmitkDataNodeRawPointerRole)
   {
     return QVariant::fromValue<mitk::DataNode *>(dataNode);
   }
 
   return QVariant();
 }
 
 bool QmitkDataStorageTreeModel::DicomPropertiesExists(const mitk::DataNode &node) const
 {
   bool propertiesExists = false;
 
   mitk::BaseProperty *seriesDescription_deprecated = (node.GetProperty("dicom.series.SeriesDescription"));
   mitk::BaseProperty *studyDescription_deprecated = (node.GetProperty("dicom.study.StudyDescription"));
   mitk::BaseProperty *patientsName_deprecated = (node.GetProperty("dicom.patient.PatientsName"));
   mitk::BaseProperty *seriesDescription =
     (node.GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x103e).c_str()));
   mitk::BaseProperty *studyDescription =
     (node.GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x1030).c_str()));
   mitk::BaseProperty *patientsName = (node.GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0010, 0x0010).c_str()));
 
   if (patientsName != nullptr && studyDescription != nullptr && seriesDescription != nullptr)
   {
     if ((!patientsName->GetValueAsString().empty()) && (!studyDescription->GetValueAsString().empty()) &&
         (!seriesDescription->GetValueAsString().empty()))
     {
       propertiesExists = true;
     }
   }
 
   /** Code coveres the deprecated property naming for backwards compatibility */
   if (patientsName_deprecated != nullptr && studyDescription_deprecated != nullptr && seriesDescription_deprecated != nullptr)
   {
     if ((!patientsName_deprecated->GetValueAsString().empty()) &&
         (!studyDescription_deprecated->GetValueAsString().empty()) &&
         (!seriesDescription_deprecated->GetValueAsString().empty()))
     {
       propertiesExists = true;
     }
   }
 
   return propertiesExists;
 }
 
 QVariant QmitkDataStorageTreeModel::headerData(int /*section*/, Qt::Orientation orientation, int role) const
 {
   if (orientation == Qt::Horizontal && role == Qt::DisplayRole && m_Root)
     return QString::fromStdString(m_Root->GetDataNode()->GetName());
 
   return QVariant();
 }
 
 void QmitkDataStorageTreeModel::SetDataStorage(mitk::DataStorage *_DataStorage)
 {
   if (m_DataStorage != _DataStorage) // dont take the same again
   {
     auto dataStorage = m_DataStorage.Lock();
     if (dataStorage.IsNotNull())
     {
       // remove Listener for the data storage itself
       dataStorage->RemoveObserver(m_DataStorageDeletedTag);
 
       // remove listeners for the nodes
       dataStorage->AddNodeEvent.RemoveListener(
         mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(this,
                                                                                   &QmitkDataStorageTreeModel::AddNode));
 
       dataStorage->ChangedNodeEvent.RemoveListener(
         mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(
           this, &QmitkDataStorageTreeModel::SetNodeModified));
 
       dataStorage->RemoveNodeEvent.RemoveListener(
         mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(
           this, &QmitkDataStorageTreeModel::RemoveNode));
     }
 
     this->beginResetModel();
 
     // take over the new data storage
     m_DataStorage = _DataStorage;
 
     // delete the old root (if necessary, create new)
     if (m_Root)
       m_Root->Delete();
     mitk::DataNode::Pointer rootDataNode = mitk::DataNode::New();
     rootDataNode->SetName("Data Manager");
     m_Root = new TreeItem(rootDataNode, nullptr);
 
     dataStorage = m_DataStorage.Lock();
     if (dataStorage.IsNotNull())
     {
       // add Listener for the data storage itself
       auto command = itk::SimpleMemberCommand<QmitkDataStorageTreeModel>::New();
       command->SetCallbackFunction(this, &QmitkDataStorageTreeModel::SetDataStorageDeleted);
       m_DataStorageDeletedTag = dataStorage->AddObserver(itk::DeleteEvent(), command);
 
       // add listeners for the nodes
       dataStorage->AddNodeEvent.AddListener(mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(
         this, &QmitkDataStorageTreeModel::AddNode));
 
       dataStorage->ChangedNodeEvent.AddListener(
         mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(
           this, &QmitkDataStorageTreeModel::SetNodeModified));
 
       dataStorage->RemoveNodeEvent.AddListener(
         mitk::MessageDelegate1<QmitkDataStorageTreeModel, const mitk::DataNode *>(
           this, &QmitkDataStorageTreeModel::RemoveNode));
 
       // finally add all nodes to the model
       this->Update();
     }
 
     this->endResetModel();
   }
 }
 
 void QmitkDataStorageTreeModel::SetDataStorageDeleted()
 {
   this->SetDataStorage(nullptr);
 }
 
 void QmitkDataStorageTreeModel::AddNodeInternal(const mitk::DataNode *node)
 {
-  if (node == nullptr || m_DataStorage.IsExpired() || !m_DataStorage.Lock()->Exists(node) || m_Root->Find(node) != nullptr)
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (node == nullptr || dataStorage.IsNull() || !dataStorage->Exists(node) || m_Root->Find(node) != nullptr)
     return;
 
   // find out if we have a root node
   TreeItem *parentTreeItem = m_Root;
   QModelIndex index;
   mitk::DataNode *parentDataNode = this->GetParentNode(node);
 
   if (parentDataNode) // no top level data node
   {
     parentTreeItem = m_Root->Find(parentDataNode); // find the corresponding tree item
     if (!parentTreeItem)
     {
       this->AddNode(parentDataNode);
       parentTreeItem = m_Root->Find(parentDataNode);
       if (!parentTreeItem)
         return;
     }
 
     // get the index of this parent with the help of the grand parent
     index = this->createIndex(parentTreeItem->GetIndex(), 0, parentTreeItem);
   }
 
   // add node
   if (m_PlaceNewNodesOnTop)
   {
     // emit beginInsertRows event
     beginInsertRows(index, 0, 0);
     parentTreeItem->InsertChild(new TreeItem(const_cast<mitk::DataNode *>(node)), 0);
   }
   else
   {
     int firstRowWithASiblingBelow = 0;
     int nodeLayer = -1;
     node->GetIntProperty("layer", nodeLayer);
     for (TreeItem* siblingTreeItem: parentTreeItem->GetChildren())
     {
       int siblingLayer = -1;
       if (mitk::DataNode* siblingNode = siblingTreeItem->GetDataNode())
       {
         siblingNode->GetIntProperty("layer", siblingLayer);
       }
       if (nodeLayer > siblingLayer)
       {
         break;
       }
       ++firstRowWithASiblingBelow;
     }
     beginInsertRows(index, firstRowWithASiblingBelow, firstRowWithASiblingBelow);
     parentTreeItem->InsertChild(new TreeItem(const_cast<mitk::DataNode*>(node)), firstRowWithASiblingBelow);
   }
 
   // emit endInsertRows event
   endInsertRows();
 
   if(m_PlaceNewNodesOnTop)
   {
     this->AdjustLayerProperty();
   }
 }
 
 void QmitkDataStorageTreeModel::AddNode(const mitk::DataNode *node)
 {
-  if (node == nullptr || m_BlockDataStorageEvents || m_DataStorage.IsExpired() || !m_DataStorage.Lock()->Exists(node) ||
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (node == nullptr || m_BlockDataStorageEvents || dataStorage.IsNull() || !dataStorage->Exists(node) ||
       m_Root->Find(node) != nullptr)
     return;
 
   this->AddNodeInternal(node);
 }
 
 void QmitkDataStorageTreeModel::SetPlaceNewNodesOnTop(bool _PlaceNewNodesOnTop)
 {
   m_PlaceNewNodesOnTop = _PlaceNewNodesOnTop;
 }
 
 void QmitkDataStorageTreeModel::RemoveNodeInternal(const mitk::DataNode *node)
 {
   if (!m_Root)
     return;
 
   TreeItem *treeItem = m_Root->Find(node);
   if (!treeItem)
     return; // return because there is no treeitem containing this node
 
   TreeItem *parentTreeItem = treeItem->GetParent();
   QModelIndex parentIndex = this->IndexFromTreeItem(parentTreeItem);
 
   // emit beginRemoveRows event (QModelIndex is empty because we dont have a tree model)
   this->beginRemoveRows(parentIndex, treeItem->GetIndex(), treeItem->GetIndex());
 
   // remove node
   std::vector<TreeItem*> children = treeItem->GetChildren();
   delete treeItem;
 
   // emit endRemoveRows event
   endRemoveRows();
 
   // move all children of deleted node into its parent
   for (std::vector<TreeItem*>::iterator it = children.begin(); it != children.end(); it++)
   {
     // emit beginInsertRows event
     beginInsertRows(parentIndex, parentTreeItem->GetChildCount(), parentTreeItem->GetChildCount());
 
     // add nodes again
     parentTreeItem->AddChild(*it);
 
     // emit endInsertRows event
     endInsertRows();
   }
 
   this->AdjustLayerProperty();
 }
 
 void QmitkDataStorageTreeModel::RemoveNode(const mitk::DataNode *node)
 {
   if (node == nullptr || m_BlockDataStorageEvents)
     return;
 
   this->RemoveNodeInternal(node);
 }
 
 void QmitkDataStorageTreeModel::SetNodeModified(const mitk::DataNode *node)
 {
   TreeItem *treeItem = m_Root->Find(node);
   if (treeItem)
   {
     TreeItem *parentTreeItem = treeItem->GetParent();
     // as the root node should not be removed one should always have a parent item
     if (!parentTreeItem)
       return;
     QModelIndex index = this->createIndex(treeItem->GetIndex(), 0, treeItem);
 
     // now emit the dataChanged signal
     emit dataChanged(index, index);
   }
 }
 
 mitk::DataNode *QmitkDataStorageTreeModel::GetParentNode(const mitk::DataNode *node) const
 {
   mitk::DataNode *dataNode = nullptr;
 
   mitk::DataStorage::SetOfObjects::ConstPointer _Sources = m_DataStorage.Lock()->GetSources(node);
 
   if (_Sources->Size() > 0)
     dataNode = _Sources->front();
 
   return dataNode;
 }
 
 bool QmitkDataStorageTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
   mitk::DataNode *dataNode = this->TreeItemFromIndex(index)->GetDataNode();
   if (!dataNode)
     return false;
 
   if (role == Qt::EditRole && !value.toString().isEmpty())
   {
     dataNode->SetStringProperty("name", value.toString().toStdString().c_str());
 
     mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(dataNode->GetData());
 
     if (planarFigure != nullptr)
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else if (role == Qt::CheckStateRole)
   {
     // Please note: value.toInt() returns 2, independentely from the actual checkstate of the index element.
     // Therefore the checkstate is being estimated again here.
 
     QVariant qcheckstate = index.data(Qt::CheckStateRole);
     int checkstate = qcheckstate.toInt();
     bool isVisible = bool(checkstate);
     dataNode->SetVisibility(!isVisible);
     emit nodeVisibilityChanged();
   }
   // inform listeners about changes
   emit dataChanged(index, index);
   return true;
 }
 
 bool QmitkDataStorageTreeModel::setHeaderData(int /*section*/,
                                               Qt::Orientation /*orientation*/,
                                               const QVariant & /* value */,
                                               int /*role = Qt::EditRole*/)
 {
   return false;
 }
 
 void QmitkDataStorageTreeModel::AdjustLayerProperty()
 {
   /// transform the tree into an array and set the layer property descending
   std::vector<TreeItem *> vec;
   this->TreeToVector(m_Root, vec);
 
   int i = vec.size() - 1;
   for (std::vector<TreeItem *>::const_iterator it = vec.begin(); it != vec.end(); ++it)
   {
     mitk::DataNode::Pointer dataNode = (*it)->GetDataNode();
     bool fixedLayer = false;
 
     if (!(dataNode->GetBoolProperty("fixedLayer", fixedLayer) && fixedLayer))
       dataNode->SetIntProperty("layer", i);
 
     --i;
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataStorageTreeModel::TreeToVector(TreeItem *parent, std::vector<TreeItem *> &vec) const
 {
   TreeItem *current;
   for (int i = 0; i < parent->GetChildCount(); ++i)
   {
     current = parent->GetChild(i);
     this->TreeToVector(current, vec);
     vec.push_back(current);
   }
 }
 
 QModelIndex QmitkDataStorageTreeModel::IndexFromTreeItem(TreeItem *item) const
 {
   if (item == m_Root)
     return QModelIndex();
   else
     return this->createIndex(item->GetIndex(), 0, item);
 }
 
 QList<mitk::DataNode::Pointer> QmitkDataStorageTreeModel::GetNodeSet() const
 {
   QList<mitk::DataNode::Pointer> res;
   if (m_Root)
     this->TreeToNodeSet(m_Root, res);
 
   return res;
 }
 
 void QmitkDataStorageTreeModel::TreeToNodeSet(TreeItem *parent, QList<mitk::DataNode::Pointer> &vec) const
 {
   TreeItem *current;
   for (int i = 0; i < parent->GetChildCount(); ++i)
   {
     current = parent->GetChild(i);
     vec.push_back(current->GetDataNode());
     this->TreeToNodeSet(current, vec);
   }
 }
 
 QModelIndex QmitkDataStorageTreeModel::GetIndex(const mitk::DataNode *node) const
 {
   if (m_Root)
   {
     TreeItem *item = m_Root->Find(node);
     if (item)
       return this->IndexFromTreeItem(item);
   }
   return QModelIndex();
 }
 
 QList<QmitkDataStorageTreeModel::TreeItem *> QmitkDataStorageTreeModel::ToTreeItemPtrList(const QMimeData *mimeData)
 {
   if (mimeData == nullptr || !mimeData->hasFormat(QmitkMimeTypes::DataStorageTreeItemPtrs))
   {
     return QList<TreeItem *>();
   }
   return ToTreeItemPtrList(mimeData->data(QmitkMimeTypes::DataStorageTreeItemPtrs));
 }
 
 QList<QmitkDataStorageTreeModel::TreeItem *> QmitkDataStorageTreeModel::ToTreeItemPtrList(const QByteArray &ba)
 {
   QList<TreeItem *> result;
   QDataStream ds(ba);
   while (!ds.atEnd())
   {
     quintptr treeItemPtr;
     ds >> treeItemPtr;
     result.push_back(reinterpret_cast<TreeItem *>(treeItemPtr));
   }
   return result;
 }
 
 void QmitkDataStorageTreeModel::Update()
 {
   auto datastorage = m_DataStorage.Lock();
   if (datastorage.IsNotNull())
   {
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = datastorage->GetAll();
 
     /// Regardless the value of this preference, the new nodes must not be inserted
     /// at the top now, but at the position according to their layer.
     bool newNodesWereToBePlacedOnTop = m_PlaceNewNodesOnTop;
     m_PlaceNewNodesOnTop = false;
 
     for (const auto& node : *_NodeSet)
     {
       this->AddNodeInternal(node);
     }
 
     m_PlaceNewNodesOnTop = newNodesWereToBePlacedOnTop;
 
     /// Adjust the layers to ensure that derived nodes are above their sources.
     this->AdjustLayerProperty();
   }
 }
 
 void QmitkDataStorageTreeModel::SetAllowHierarchyChange(bool allowHierarchyChange)
 {
   m_AllowHierarchyChange = allowHierarchyChange;
 }
diff --git a/Modules/QtWidgets/src/QmitkLevelWindowPresetDefinition.ui b/Modules/QtWidgets/src/QmitkLevelWindowPresetDefinition.ui
index eae4a991a0..62fe48e86f 100644
--- a/Modules/QtWidgets/src/QmitkLevelWindowPresetDefinition.ui
+++ b/Modules/QtWidgets/src/QmitkLevelWindowPresetDefinition.ui
@@ -1,231 +1,231 @@
 <ui version="4.0" >
  <class>QmitkLevelWindowPresetDefinition</class>
  <widget class="QDialog" name="QmitkLevelWindowPresetDefinition" >
   <property name="windowModality" >
    <enum>Qt::NonModal</enum>
   </property>
   <property name="geometry" >
    <rect>
     <x>0</x>
     <y>0</y>
     <width>646</width>
     <height>281</height>
    </rect>
   </property>
   <property name="sizePolicy" >
    <sizepolicy vsizetype="MinimumExpanding" hsizetype="MinimumExpanding" >
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize" >
    <size>
     <width>610</width>
     <height>280</height>
    </size>
   </property>
   <property name="windowTitle" >
    <string>Preset definition</string>
   </property>
   <property name="sizeGripEnabled" >
    <bool>true</bool>
   </property>
   <property name="modal" >
    <bool>true</bool>
   </property>
   <layout class="QHBoxLayout" >
    <item>
     <widget class="QTableView" name="presetView" >
      <property name="selectionMode" >
       <enum>QAbstractItemView::SingleSelection</enum>
      </property>
      <property name="selectionBehavior" >
       <enum>QAbstractItemView::SelectRows</enum>
      </property>
      <property name="showGrid" >
       <bool>false</bool>
      </property>
      <property name="sortingEnabled" >
       <bool>true</bool>
      </property>
      <property name="cornerButtonEnabled" >
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QVBoxLayout" >
      <item>
       <layout class="QGridLayout" >
        <item row="0" column="0" >
         <widget class="QLabel" name="presetnameLabel" >
          <property name="text" >
           <string>Preset:</string>
          </property>
          <property name="wordWrap" >
           <bool>false</bool>
          </property>
         </widget>
        </item>
        <item row="0" column="1" colspan="2" >
         <widget class="QLineEdit" name="presetnameLineEdit" />
        </item>
        <item row="1" column="0" >
         <widget class="QLabel" name="levelLabel" >
          <property name="text" >
           <string>Level:</string>
          </property>
          <property name="wordWrap" >
           <bool>false</bool>
          </property>
         </widget>
        </item>
        <item row="1" column="1" >
-        <widget class="QSpinBox" name="levelSpinBox" >
+        <widget class="QDoubleSpinBox" name="levelSpinBox" >
          <property name="minimum" >
-          <number>-1024</number>
+          <number>-100000</number>
          </property>
          <property name="maximum" >
-          <number>3072</number>
+          <number>100000</number>
          </property>
         </widget>
        </item>
        <item row="2" column="0" >
         <widget class="QLabel" name="windowLabel" >
          <property name="text" >
           <string>Window:</string>
          </property>
          <property name="wordWrap" >
           <bool>false</bool>
          </property>
         </widget>
        </item>
        <item row="2" column="1" >
-        <widget class="QSpinBox" name="windowSpinBox" >
+        <widget class="QDoubleSpinBox" name="windowSpinBox" >
          <property name="maximum" >
-          <number>4096</number>
+          <number>100000</number>
          </property>
         </widget>
        </item>
        <item row="3" column="0" >
         <widget class="QPushButton" name="addButton" >
          <property name="text" >
           <string>Add preset</string>
          </property>
         </widget>
        </item>
        <item row="3" column="1" >
         <widget class="QPushButton" name="changeButton" >
          <property name="text" >
           <string>Change</string>
          </property>
         </widget>
        </item>
        <item row="3" column="2" >
         <widget class="QPushButton" name="removeButton" >
          <property name="text" >
           <string>Delete preset</string>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item>
       <spacer>
        <property name="orientation" >
         <enum>Qt::Vertical</enum>
        </property>
        <property name="sizeType" >
         <enum>QSizePolicy::Expanding</enum>
        </property>
        <property name="sizeHint" >
         <size>
          <width>20</width>
          <height>91</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <layout class="QHBoxLayout" >
        <item>
         <spacer>
          <property name="orientation" >
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="sizeType" >
           <enum>QSizePolicy::Expanding</enum>
          </property>
          <property name="sizeHint" >
           <size>
            <width>204</width>
            <height>20</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="QPushButton" name="okButton" >
          <property name="text" >
           <string>OK</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QPushButton" name="cancelButton" >
          <property name="text" >
           <string>Cancel</string>
          </property>
         </widget>
        </item>
       </layout>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11" />
  <tabstops>
   <tabstop>addButton</tabstop>
   <tabstop>removeButton</tabstop>
   <tabstop>changeButton</tabstop>
   <tabstop>presetnameLineEdit</tabstop>
   <tabstop>okButton</tabstop>
   <tabstop>cancelButton</tabstop>
  </tabstops>
  <resources/>
  <connections>
   <connection>
    <sender>okButton</sender>
    <signal>clicked()</signal>
    <receiver>QmitkLevelWindowPresetDefinition</receiver>
    <slot>accept()</slot>
    <hints>
     <hint type="sourcelabel" >
      <x>460</x>
      <y>263</y>
     </hint>
     <hint type="destinationlabel" >
      <x>20</x>
      <y>20</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>cancelButton</sender>
    <signal>clicked()</signal>
    <receiver>QmitkLevelWindowPresetDefinition</receiver>
    <slot>reject()</slot>
    <hints>
     <hint type="sourcelabel" >
      <x>545</x>
      <y>263</y>
     </hint>
     <hint type="destinationlabel" >
      <x>20</x>
      <y>20</y>
     </hint>
    </hints>
   </connection>
  </connections>
 </ui>
diff --git a/Modules/QtWidgets/src/QmitkLevelWindowRangeChange.ui b/Modules/QtWidgets/src/QmitkLevelWindowRangeChange.ui
index 471c8813c4..3257ed70ab 100644
--- a/Modules/QtWidgets/src/QmitkLevelWindowRangeChange.ui
+++ b/Modules/QtWidgets/src/QmitkLevelWindowRangeChange.ui
@@ -1,129 +1,129 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkLevelWindowRangeChange</class>
  <widget class="QDialog" name="QmitkLevelWindowRangeChange">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>270</width>
     <height>110</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
     <width>210</width>
     <height>110</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>270</width>
     <height>111</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>Change Scale Range</string>
   </property>
   <layout class="QGridLayout">
    <item row="2" column="0" colspan="2">
     <widget class="QPushButton" name="okButton">
      <property name="text">
       <string>OK</string>
      </property>
      <property name="autoDefault">
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item row="1" column="0">
     <widget class="QLabel" name="lowerLimitLabel">
      <property name="text">
       <string>Lower Limit:</string>
      </property>
      <property name="wordWrap">
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item row="0" column="0">
     <widget class="QLabel" name="upperLimitLabel">
      <property name="text">
       <string>Upper Limit:</string>
      </property>
      <property name="wordWrap">
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item row="2" column="2">
     <widget class="QPushButton" name="cancelButton">
      <property name="text">
       <string>Cancel</string>
      </property>
      <property name="autoDefault">
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item row="0" column="1" colspan="2">
     <widget class="QDoubleSpinBox" name="rangeMaxDoubleSpinBox">
      <property name="decimals">
-      <number>10</number>
+      <number>2</number>
      </property>
      <property name="minimum">
-      <double>-999999.999998999992386</double>
+      <double>-1000000.000000000000000</double>
      </property>
      <property name="maximum">
-      <double>999999.999998999992386</double>
+      <double>1000000.000000000000000</double>
      </property>
     </widget>
    </item>
    <item row="1" column="1" colspan="2">
     <widget class="QDoubleSpinBox" name="rangeMinDoubleSpinBox">
      <property name="decimals">
-      <number>10</number>
+      <number>2</number>
      </property>
      <property name="minimum">
-      <double>-999999.999998999992386</double>
+      <double>-1000000.000000000000000</double>
      </property>
      <property name="maximum">
-      <double>999999.999998999992386</double>
+      <double>1000000.000000000000000</double>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <tabstops>
   <tabstop>rangeMaxDoubleSpinBox</tabstop>
   <tabstop>rangeMinDoubleSpinBox</tabstop>
   <tabstop>okButton</tabstop>
   <tabstop>cancelButton</tabstop>
  </tabstops>
  <resources/>
  <connections>
   <connection>
    <sender>cancelButton</sender>
    <signal>clicked()</signal>
    <receiver>QmitkLevelWindowRangeChange</receiver>
    <slot>reject()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>146</x>
      <y>91</y>
     </hint>
     <hint type="destinationlabel">
      <x>20</x>
      <y>20</y>
     </hint>
    </hints>
   </connection>
  </connections>
 </ui>
diff --git a/Modules/QtWidgets/src/QmitkPropertiesTableModel.cpp b/Modules/QtWidgets/src/QmitkPropertiesTableModel.cpp
index a89b2af14c..5fd79e13bf 100644
--- a/Modules/QtWidgets/src/QmitkPropertiesTableModel.cpp
+++ b/Modules/QtWidgets/src/QmitkPropertiesTableModel.cpp
@@ -1,528 +1,530 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkPropertiesTableModel.h"
 
 //# Own includes
 #include "QmitkCustomVariants.h"
 #include "mitkColorProperty.h"
 #include "mitkEnumerationProperty.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkStringProperty.h"
 
 //# Toolkit includes
 #include <QBrush>
 #include <QColor>
 #include <QStringList>
 #include <itkCommand.h>
 
 //# PUBLIC CTORS,DTOR
 QmitkPropertiesTableModel::QmitkPropertiesTableModel(QObject *parent, mitk::PropertyList::Pointer _PropertyList)
   : QAbstractTableModel(parent),
     m_PropertyList(nullptr),
     m_BlockEvents(false),
     m_SortDescending(false),
     m_FilterKeyWord("")
 {
   this->SetPropertyList(_PropertyList);
 }
 
 QmitkPropertiesTableModel::~QmitkPropertiesTableModel()
 {
   // remove all event listeners by setting the property list to 0
   this->SetPropertyList(nullptr);
 }
 
 //# PUBLIC GETTER
 mitk::PropertyList::Pointer QmitkPropertiesTableModel::GetPropertyList() const
 {
   return m_PropertyList.Lock();
 }
 
 Qt::ItemFlags QmitkPropertiesTableModel::flags(const QModelIndex &index) const
 {
   // no editing so far, return default (enabled, selectable)
   Qt::ItemFlags flags = QAbstractItemModel::flags(index);
 
   if (index.column() == PROPERTY_VALUE_COLUMN)
   {
     // there are also read only property items -> do not allow editing them
     if (index.data(Qt::EditRole).isValid())
       flags |= Qt::ItemIsEditable;
 
     if (index.data(Qt::CheckStateRole).isValid())
       flags |= Qt::ItemIsUserCheckable;
   }
 
   return flags;
 }
 
 QVariant QmitkPropertiesTableModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (role != Qt::DisplayRole)
     return QVariant();
 
   if (orientation == Qt::Horizontal)
   {
     switch (section)
     {
       case PROPERTY_NAME_COLUMN:
         return tr("Name");
 
       case PROPERTY_VALUE_COLUMN:
         return tr("Value");
 
       default:
         return QVariant();
     }
   }
 
   return QVariant();
 }
 
 QVariant QmitkPropertiesTableModel::data(const QModelIndex &index, int role) const
 {
   // empty data by default
   QVariant data;
 
   if (!index.isValid() || m_SelectedProperties.empty() || index.row() > (int)(m_SelectedProperties.size() - 1))
     return data;
 
   // the properties name
   if (index.column() == PROPERTY_NAME_COLUMN)
   {
     if (role == Qt::DisplayRole)
       data = QString::fromStdString(m_SelectedProperties[index.row()].first);
   }
   // the real properties value
   else if (index.column() == PROPERTY_VALUE_COLUMN)
   {
     mitk::BaseProperty *baseProp = m_SelectedProperties[index.row()].second;
 
     if (const mitk::ColorProperty *colorProp = dynamic_cast<const mitk::ColorProperty *>(baseProp))
     {
       mitk::Color col = colorProp->GetColor();
       QColor qcol((int)(col.GetRed() * 255), (int)(col.GetGreen() * 255), (int)(col.GetBlue() * 255));
       if (role == Qt::DisplayRole)
         data.setValue<QColor>(qcol);
       else if (role == Qt::EditRole)
         data.setValue<QColor>(qcol);
     }
 
     else if (mitk::BoolProperty *boolProp = dynamic_cast<mitk::BoolProperty *>(baseProp))
     {
       if (role == Qt::CheckStateRole)
         data = boolProp->GetValue() ? Qt::Checked : Qt::Unchecked;
     }
 
     else if (mitk::StringProperty *stringProp = dynamic_cast<mitk::StringProperty *>(baseProp))
     {
       if (role == Qt::DisplayRole)
         data.setValue<QString>(QString::fromStdString(stringProp->GetValue()));
       else if (role == Qt::EditRole)
         data.setValue<QString>(QString::fromStdString(stringProp->GetValue()));
     }
 
     else if (mitk::IntProperty *intProp = dynamic_cast<mitk::IntProperty *>(baseProp))
     {
       if (role == Qt::DisplayRole)
         data.setValue<int>(intProp->GetValue());
       else if (role == Qt::EditRole)
         data.setValue<int>(intProp->GetValue());
     }
 
     else if (mitk::FloatProperty *floatProp = dynamic_cast<mitk::FloatProperty *>(baseProp))
     {
       if (role == Qt::DisplayRole)
         data.setValue<float>(floatProp->GetValue());
       else if (role == Qt::EditRole)
         data.setValue<float>(floatProp->GetValue());
     }
 
     else if (mitk::EnumerationProperty *enumerationProp = dynamic_cast<mitk::EnumerationProperty *>(baseProp))
     {
       if (role == Qt::DisplayRole)
         data.setValue<QString>(QString::fromStdString(baseProp->GetValueAsString()));
       else if (role == Qt::EditRole)
       {
         QStringList values;
         for (auto it = enumerationProp->Begin(); it != enumerationProp->End(); it++)
         {
           values << QString::fromStdString(it->second);
         }
         data.setValue<QStringList>(values);
       }
     }
 
     else
     {
       if (role == Qt::DisplayRole)
         data.setValue<QString>(QString::fromStdString(m_SelectedProperties[index.row()].second->GetValueAsString()));
     }
   }
 
   return data;
 }
 
 int QmitkPropertiesTableModel::rowCount(const QModelIndex & /*parent*/) const
 {
   // return the number of properties in the properties list.
   return m_SelectedProperties.size();
 }
 
 int QmitkPropertiesTableModel::columnCount(const QModelIndex & /*parent*/) const
 {
   return 2;
 }
 
 //# PUBLIC SETTER
 void QmitkPropertiesTableModel::SetPropertyList(mitk::PropertyList *_PropertyList)
 {
   // if propertylist really changed
   if (m_PropertyList != _PropertyList)
   {
+    auto propertyList = m_PropertyList.Lock();
     // Remove delete listener if there was a propertylist before
-    if (!m_PropertyList.IsExpired())
-      m_PropertyList.Lock()->RemoveObserver(m_PropertyListDeleteObserverTag);
+    if (propertyList.IsNotNull())
+      propertyList->RemoveObserver(m_PropertyListDeleteObserverTag);
 
     // set new list
     m_PropertyList = _PropertyList;
+    propertyList = m_PropertyList.Lock();
 
-    if (!m_PropertyList.IsExpired())
+    if (propertyList.IsNotNull())
     {
       auto command = itk::SimpleMemberCommand<QmitkPropertiesTableModel>::New();
       command->SetCallbackFunction(this, &QmitkPropertiesTableModel::PropertyListDelete);
-      m_PropertyListDeleteObserverTag = m_PropertyList.Lock()->AddObserver(itk::DeleteEvent(), command);
+      m_PropertyListDeleteObserverTag = propertyList->AddObserver(itk::DeleteEvent(), command);
     }
     this->Reset();
   }
 }
 
 void QmitkPropertiesTableModel::PropertyListDelete()
 {
   if (!m_BlockEvents)
   {
     m_BlockEvents = true;
     this->Reset();
     m_BlockEvents = false;
   }
 }
 
 void QmitkPropertiesTableModel::PropertyModified(const itk::Object *caller, const itk::EventObject & /*event*/)
 {
   if (!m_BlockEvents)
   {
     m_BlockEvents = true;
     int row = this->FindProperty(dynamic_cast<const mitk::BaseProperty *>(caller));
 
     QModelIndex indexOfChangedProperty = index(row, 1);
 
     emit dataChanged(indexOfChangedProperty, indexOfChangedProperty);
     m_BlockEvents = false;
   }
 }
 
 void QmitkPropertiesTableModel::PropertyDelete(const itk::Object *caller, const itk::EventObject & /*event*/)
 {
   if (!m_BlockEvents)
   {
     m_BlockEvents = true;
     int row = this->FindProperty(dynamic_cast<const mitk::BaseProperty *>(caller));
     if (row >= 0)
       this->Reset();
     m_BlockEvents = false;
   }
 }
 
 bool QmitkPropertiesTableModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
   // TODO: check 'role' condition
   if (index.isValid() && !m_SelectedProperties.empty() && index.row() < (int)(m_SelectedProperties.size()) &&
       (role == Qt::EditRole || role == Qt::CheckStateRole))
   {
     // block all events now!
     m_BlockEvents = true;
 
     auto propertyList = m_PropertyList.Lock();
 
     // the properties name
     if (index.column() == PROPERTY_VALUE_COLUMN)
     {
       mitk::BaseProperty *baseProp = m_SelectedProperties[index.row()].second;
 
       if (mitk::ColorProperty *colorProp = dynamic_cast<mitk::ColorProperty *>(baseProp))
       {
         QColor qcolor = value.value<QColor>();
         if (!qcolor.isValid())
           return false;
 
         mitk::Color col = colorProp->GetColor();
         col.SetRed(qcolor.red() / 255.0);
         col.SetGreen(qcolor.green() / 255.0);
         col.SetBlue(qcolor.blue() / 255.0);
         colorProp->SetColor(col);
         propertyList->InvokeEvent(itk::ModifiedEvent());
         propertyList->Modified();
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
 
       else if (mitk::BoolProperty *boolProp = dynamic_cast<mitk::BoolProperty *>(baseProp))
       {
         boolProp->SetValue(value.toInt() == Qt::Checked ? true : false);
         propertyList->InvokeEvent(itk::ModifiedEvent());
         propertyList->Modified();
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
 
       else if (mitk::StringProperty *stringProp = dynamic_cast<mitk::StringProperty *>(baseProp))
       {
         stringProp->SetValue((value.value<QString>()).toStdString());
         propertyList->InvokeEvent(itk::ModifiedEvent());
         propertyList->Modified();
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
 
       else if (mitk::IntProperty *intProp = dynamic_cast<mitk::IntProperty *>(baseProp))
       {
         int intValue = value.value<int>();
         if (intValue != intProp->GetValue())
         {
           intProp->SetValue(intValue);
           propertyList->InvokeEvent(itk::ModifiedEvent());
           propertyList->Modified();
 
           mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
       }
 
       else if (mitk::FloatProperty *floatProp = dynamic_cast<mitk::FloatProperty *>(baseProp))
       {
         float floatValue = value.value<float>();
         if (floatValue != floatProp->GetValue())
         {
           floatProp->SetValue(floatValue);
           propertyList->InvokeEvent(itk::ModifiedEvent());
           propertyList->Modified();
 
           mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
       }
 
       else if (mitk::EnumerationProperty *enumerationProp = dynamic_cast<mitk::EnumerationProperty *>(baseProp))
       {
         std::string activatedItem = value.value<QString>().toStdString();
         if (activatedItem != enumerationProp->GetValueAsString())
         {
           if (enumerationProp->IsValidEnumerationValue(activatedItem))
           {
             enumerationProp->SetValue(activatedItem);
             propertyList->InvokeEvent(itk::ModifiedEvent());
             propertyList->Modified();
 
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
           }
         }
       }
     }
 
     // property was changed by us, now we can accept property changes triggered by someone else
     m_BlockEvents = false;
     emit dataChanged(index, index);
     return true;
   }
 
   return false;
 }
 
 void QmitkPropertiesTableModel::sort(int column, Qt::SortOrder order /*= Qt::AscendingOrder */)
 {
   bool sortDescending = (order == Qt::DescendingOrder) ? true : false;
 
   // do not sort twice !!! (dont know why, but qt calls this func twice. STUPID!)
   if (sortDescending != m_SortDescending)
   {
     m_SortDescending = sortDescending;
 
     PropertyDataSetCompareFunction::CompareCriteria _CompareCriteria = PropertyDataSetCompareFunction::CompareByName;
 
     PropertyDataSetCompareFunction::CompareOperator _CompareOperator =
       m_SortDescending ? PropertyDataSetCompareFunction::Greater : PropertyDataSetCompareFunction::Less;
 
     if (column == PROPERTY_VALUE_COLUMN)
       _CompareCriteria = PropertyDataSetCompareFunction::CompareByValue;
 
     PropertyDataSetCompareFunction compareFunc(_CompareCriteria, _CompareOperator);
     std::sort(m_SelectedProperties.begin(), m_SelectedProperties.end(), compareFunc);
 
     QAbstractTableModel::beginResetModel();
     QAbstractTableModel::endResetModel();
   }
 }
 
 //# PROTECTED GETTER
 int QmitkPropertiesTableModel::FindProperty(const mitk::BaseProperty *_Property) const
 {
   int row = -1;
 
   if (_Property)
   {
     // search for property that changed and emit datachanged on the corresponding ModelIndex
     std::vector<PropertyDataSet>::const_iterator propertyIterator;
 
     for (propertyIterator = m_SelectedProperties.begin(); propertyIterator != m_SelectedProperties.end();
          propertyIterator++)
     {
       if (propertyIterator->second == _Property)
         break;
     }
 
     if (propertyIterator != m_SelectedProperties.end())
       row = std::distance(m_SelectedProperties.begin(), propertyIterator);
   }
 
   return row;
 }
 
 //# PROTECTED SETTER
 void QmitkPropertiesTableModel::AddSelectedProperty(PropertyDataSet &_PropertyDataSet)
 {
   // subscribe for modified event
   itk::MemberCommand<QmitkPropertiesTableModel>::Pointer _PropertyDataSetModifiedCommand =
     itk::MemberCommand<QmitkPropertiesTableModel>::New();
   _PropertyDataSetModifiedCommand->SetCallbackFunction(this, &QmitkPropertiesTableModel::PropertyModified);
   m_PropertyModifiedObserverTags.push_back(
     _PropertyDataSet.second->AddObserver(itk::ModifiedEvent(), _PropertyDataSetModifiedCommand));
 
   // subscribe for delete event
   itk::MemberCommand<QmitkPropertiesTableModel>::Pointer _PropertyDataSetDeleteCommand =
     itk::MemberCommand<QmitkPropertiesTableModel>::New();
   _PropertyDataSetDeleteCommand->SetCallbackFunction(this, &QmitkPropertiesTableModel::PropertyDelete);
   m_PropertyDeleteObserverTags.push_back(
     _PropertyDataSet.second->AddObserver(itk::DeleteEvent(), _PropertyDataSetDeleteCommand));
 
   // add to the selection
   m_SelectedProperties.push_back(_PropertyDataSet);
 }
 
 void QmitkPropertiesTableModel::RemoveSelectedProperty(unsigned int _Index)
 {
   PropertyDataSet &_PropertyDataSet = m_SelectedProperties.at(_Index);
 
   // remove modified event listener
   _PropertyDataSet.second->RemoveObserver(m_PropertyModifiedObserverTags[_Index]);
   m_PropertyModifiedObserverTags.erase(m_PropertyModifiedObserverTags.begin() + _Index);
   // remove delete event listener
   _PropertyDataSet.second->RemoveObserver(m_PropertyDeleteObserverTags[_Index]);
   m_PropertyDeleteObserverTags.erase(m_PropertyDeleteObserverTags.begin() + _Index);
   // remove from selection
   m_SelectedProperties.erase(m_SelectedProperties.begin() + _Index);
 }
 
 void QmitkPropertiesTableModel::Reset()
 {
   // remove all selected properties
   while (!m_SelectedProperties.empty())
   {
     this->RemoveSelectedProperty(m_SelectedProperties.size() - 1);
   }
 
   std::vector<PropertyDataSet> allPredicates;
-  if (!m_PropertyList.IsExpired())
-  {
-    auto propertyList = m_PropertyList.Lock();
+  auto propertyList = m_PropertyList.Lock();
 
+  if (propertyList.IsNotNull())
+  {
     // first of all: collect all properties from the list
     for (auto it = propertyList->GetMap()->begin(); it != propertyList->GetMap()->end(); it++)
     {
       allPredicates.push_back(*it); //% TODO
     }
   }
   // make a subselection if a keyword is specified
   if (!m_FilterKeyWord.empty())
   {
     std::vector<PropertyDataSet> subSelection;
 
     for (auto it = allPredicates.begin(); it != allPredicates.end(); it++)
     {
       // add this to the selection if it is matched by the keyword
       if ((*it).first.find(m_FilterKeyWord) != std::string::npos)
         subSelection.push_back((*it));
     }
     allPredicates.clear();
     allPredicates = subSelection;
   }
 
   PropertyDataSet tmpPropertyDataSet;
   // add all selected now to the Model
   for (auto it = allPredicates.begin(); it != allPredicates.end(); it++)
   {
     tmpPropertyDataSet = *it;
     this->AddSelectedProperty(tmpPropertyDataSet);
   }
 
   // sort the list as indicated by m_SortDescending
   this->sort(m_SortDescending);
 
   // model was resetted
   QAbstractTableModel::beginResetModel();
   QAbstractTableModel::endResetModel();
 }
 
 void QmitkPropertiesTableModel::SetFilterPropertiesKeyWord(std::string _FilterKeyWord)
 {
   m_FilterKeyWord = _FilterKeyWord;
   this->Reset();
 }
 
 QmitkPropertiesTableModel::PropertyDataSetCompareFunction::PropertyDataSetCompareFunction(
   CompareCriteria _CompareCriteria, CompareOperator _CompareOperator)
   : m_CompareCriteria(_CompareCriteria), m_CompareOperator(_CompareOperator)
 {
 }
 
 bool QmitkPropertiesTableModel::PropertyDataSetCompareFunction::operator()(const PropertyDataSet &_Left,
                                                                            const PropertyDataSet &_Right) const
 {
   switch (m_CompareCriteria)
   {
     case CompareByValue:
       if (m_CompareOperator == Less)
         return (_Left.second->GetValueAsString() < _Right.second->GetValueAsString());
       else
         return (_Left.second->GetValueAsString() > _Right.second->GetValueAsString());
       break;
 
     // CompareByName:
     default:
       if (m_CompareOperator == Less)
         return (_Left.first < _Right.first);
       else
         return (_Left.first > _Right.first);
       break;
   }
 }
 QmitkPropertiesTableModel::PropertyListElementFilterFunction::PropertyListElementFilterFunction(
   const std::string &_FilterKeyWord)
   : m_FilterKeyWord(_FilterKeyWord)
 {
 }
 
 bool QmitkPropertiesTableModel::PropertyListElementFilterFunction::operator()(const PropertyDataSet &_Elem) const
 {
   if (m_FilterKeyWord.empty())
     return true;
   return (_Elem.first.find(m_FilterKeyWord) == 0);
 }
diff --git a/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp b/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp
index ed90dc0aa3..9eae1448e9 100644
--- a/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp
+++ b/Modules/QtWidgets/src/QmitkPropertyItemDelegate.cpp
@@ -1,380 +1,382 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkPropertyItemDelegate.h"
 #include "QmitkPropertyItemModel.h"
 #include <QApplication>
 #include <QColorDialog>
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QLineEdit>
 #include <QPaintEvent>
 #include <QPainter>
 #include <QSpinBox>
 #include <QToolButton>
 #include <algorithm>
 #include <mitkBaseProperty.h>
 #include <mitkCoreServices.h>
 #include <mitkFloatPropertyExtension.h>
 #include <mitkIPropertyExtensions.h>
 #include <mitkIntPropertyExtension.h>
 
 QmitkColorWidget::QmitkColorWidget(QWidget *parent)
   : QWidget(parent), m_LineEdit(new QLineEdit), m_Button(new QToolButton)
 {
   m_LineEdit->setText(m_Color.name());
   m_Button->setText("...");
 
   QHBoxLayout *layout = new QHBoxLayout;
   layout->setContentsMargins(0, 0, 0, 0);
   layout->setSpacing(0);
 
   layout->addWidget(m_LineEdit);
   layout->addWidget(m_Button);
 
   this->setFocusProxy(m_LineEdit);
   this->setLayout(layout);
 
   connect(m_LineEdit, SIGNAL(editingFinished()), this, SLOT(OnLineEditEditingFinished()));
   connect(m_Button, SIGNAL(clicked()), this, SLOT(OnButtonClicked()));
 }
 
 QmitkColorWidget::~QmitkColorWidget()
 {
 }
 
 QColor QmitkColorWidget::GetColor() const
 {
   return m_Color;
 }
 
 void QmitkColorWidget::SetColor(QColor color)
 {
   m_Color = color;
   m_LineEdit->setText(color.name());
 }
 
 void QmitkColorWidget::OnLineEditEditingFinished()
 {
   if (!QColor::isValidColor(m_LineEdit->text()))
     m_LineEdit->setText("#000000");
 
   m_Color.setNamedColor(m_LineEdit->text());
 }
 
 void QmitkColorWidget::OnButtonClicked()
 {
   QColor color = QColorDialog::getColor(m_Color, QApplication::activeWindow());
 
   if (color.isValid())
   {
     this->SetColor(color);
     emit ColorPicked();
   }
 }
 
 QmitkComboBoxListView::QmitkComboBoxListView(QComboBox *comboBox) : m_ComboBox(comboBox)
 {
 }
 
 QmitkComboBoxListView::~QmitkComboBoxListView()
 {
 }
 
 void QmitkComboBoxListView::paintEvent(QPaintEvent *event)
 {
   if (m_ComboBox != nullptr)
   {
     QStyleOptionComboBox option;
 
     option.initFrom(m_ComboBox);
     option.editable = m_ComboBox->isEditable();
 
     if (m_ComboBox->style()->styleHint(QStyle::SH_ComboBox_Popup, &option, m_ComboBox))
     {
       QStyleOptionMenuItem menuOption;
       menuOption.initFrom(this);
       menuOption.palette = this->palette();
       menuOption.state = QStyle::State_None;
       menuOption.checkType = QStyleOptionMenuItem::NotCheckable;
       menuOption.menuRect = event->rect();
       menuOption.maxIconWidth = 0;
       menuOption.tabWidth = 0;
 
       QPainter painter(this->viewport());
       m_ComboBox->style()->drawControl(QStyle::CE_MenuEmptyArea, &menuOption, &painter, this);
     }
   }
 
   QListView::paintEvent(event);
 }
 
 void QmitkComboBoxListView::resizeEvent(QResizeEvent *event)
 {
   int width = this->viewport()->width();
   int height = this->contentsSize().height();
 
   this->resizeContents(width, height);
 
   QListView::resizeEvent(event);
 }
 
 QStyleOptionViewItem QmitkComboBoxListView::viewOptions() const
 {
   QStyleOptionViewItem option = QListView::viewOptions();
   option.showDecorationSelected = true;
 
   if (m_ComboBox != nullptr)
     option.font = m_ComboBox->font();
 
   return option;
 }
 
 class PropertyEqualTo
 {
 public:
   PropertyEqualTo(const mitk::BaseProperty *property) : m_Property(property) {}
   bool operator()(const mitk::PropertyList::PropertyMapElementType &pair) const
   {
     return pair.second.GetPointer() == m_Property;
   }
 
 private:
   const mitk::BaseProperty *m_Property;
 };
 
 QmitkPropertyItemDelegate::QmitkPropertyItemDelegate(QObject *parent) : QStyledItemDelegate(parent)
 {
 }
 
 QmitkPropertyItemDelegate::~QmitkPropertyItemDelegate()
 {
 }
 
 QWidget *QmitkPropertyItemDelegate::createEditor(QWidget *parent,
                                                  const QStyleOptionViewItem &option,
                                                  const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (data.isValid())
   {
     if (data.type() == QVariant::Int)
     {
       QSpinBox *spinBox = new QSpinBox(parent);
 
       mitk::CoreServicePointer<mitk::IPropertyExtensions> extensions(mitk::CoreServices::GetPropertyExtensions());
       std::string name = this->GetPropertyName(index);
 
       if (!name.empty() && extensions->HasExtension(name))
       {
         mitk::IntPropertyExtension::Pointer extension =
           dynamic_cast<mitk::IntPropertyExtension *>(extensions->GetExtension(name).GetPointer());
 
         if (extension.IsNotNull())
         {
           spinBox->setMinimum(extension->GetMinimum());
           spinBox->setMaximum(extension->GetMaximum());
           spinBox->setSingleStep(extension->GetSingleStep());
         }
       }
 
       connect(spinBox, SIGNAL(editingFinished()), this, SLOT(OnSpinBoxEditingFinished()));
 
       return spinBox;
     }
 
     if (data.type() == QVariant::Double || static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
     {
       QDoubleSpinBox *spinBox = new QDoubleSpinBox(parent);
 
       mitk::CoreServicePointer<mitk::IPropertyExtensions> extensions(mitk::CoreServices::GetPropertyExtensions());
       std::string name = this->GetPropertyName(index);
 
       if (!name.empty() && extensions->HasExtension(name))
       {
         mitk::FloatPropertyExtension::Pointer extension =
           dynamic_cast<mitk::FloatPropertyExtension *>(extensions->GetExtension(name).GetPointer());
 
         if (extension.IsNotNull())
         {
           spinBox->setMinimum(extension->GetMinimum());
           spinBox->setMaximum(extension->GetMaximum());
           spinBox->setSingleStep(extension->GetSingleStep());
           spinBox->setDecimals(extension->GetDecimals());
         }
       }
       else
       {
         spinBox->setSingleStep(0.1);
         spinBox->setDecimals(4);
       }
 
       if (name == "opacity") // TODO
       {
         spinBox->setMinimum(0.0);
         spinBox->setMaximum(1.0);
       }
 
       connect(spinBox, SIGNAL(editingFinished()), this, SLOT(OnSpinBoxEditingFinished()));
 
       return spinBox;
     }
 
     if (data.type() == QVariant::StringList)
     {
       QComboBox *comboBox = new QComboBox(parent);
       comboBox->setView(new QmitkComboBoxListView(comboBox));
 
       comboBox->addItems(data.toStringList());
 
       connect(comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnComboBoxCurrentIndexChanged(int)));
 
       return comboBox;
     }
 
     if (data.type() == QVariant::Color)
     {
       QmitkColorWidget *colorWidget = new QmitkColorWidget(parent);
 
       connect(colorWidget, SIGNAL(ColorPicked()), this, SLOT(OnColorPicked()));
 
       return colorWidget;
     }
   }
 
   return QStyledItemDelegate::createEditor(parent, option, index);
 }
 
 std::string QmitkPropertyItemDelegate::GetPropertyName(const QModelIndex &index) const
 {
-  if (!m_PropertyList.IsExpired())
+  auto propertyList = m_PropertyList.Lock();
+
+  if (propertyList.IsNotNull())
   {
     mitk::BaseProperty *property =
       reinterpret_cast<mitk::BaseProperty *>(index.data(mitk::PropertyRole).value<void *>());
-    const mitk::PropertyList::PropertyMap *propertyMap = m_PropertyList.Lock()->GetMap();
+    const mitk::PropertyList::PropertyMap *propertyMap = propertyList->GetMap();
 
     mitk::PropertyList::PropertyMap::const_iterator it =
       std::find_if(propertyMap->begin(), propertyMap->end(), PropertyEqualTo(property));
 
     if (it != propertyMap->end())
       return it->first;
   }
 
   return "";
 }
 
 void QmitkPropertyItemDelegate::OnComboBoxCurrentIndexChanged(int)
 {
   QComboBox *comboBox = qobject_cast<QComboBox *>(sender());
 
   emit commitData(comboBox);
   emit closeEditor(comboBox);
 }
 
 void QmitkPropertyItemDelegate::OnSpinBoxEditingFinished()
 {
   QAbstractSpinBox *spinBox = qobject_cast<QAbstractSpinBox *>(sender());
 
   emit commitData(spinBox);
   emit closeEditor(spinBox);
 }
 
 void QmitkPropertyItemDelegate::OnColorPicked()
 {
   QmitkColorWidget *colorWidget = qobject_cast<QmitkColorWidget *>(sender());
 
   emit commitData(colorWidget);
   emit closeEditor(colorWidget);
 }
 
 void QmitkPropertyItemDelegate::paint(QPainter *painter,
                                       const QStyleOptionViewItem &option,
                                       const QModelIndex &index) const
 {
   QVariant data = index.data();
 
   if (index.column() == 1 && data.type() == QVariant::Color)
   {
     painter->fillRect(option.rect, data.value<QColor>());
     return;
   }
 
   QStyledItemDelegate::paint(painter, option, index);
 }
 
 void QmitkPropertyItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (!data.isValid())
     return;
 
   if (data.type() == QVariant::StringList)
   {
     QComboBox *comboBox = qobject_cast<QComboBox *>(editor);
     comboBox->setCurrentIndex(comboBox->findText(index.data().toString()));
   }
   if (data.type() == QVariant::Color)
   {
     QmitkColorWidget *colorWidget = qobject_cast<QmitkColorWidget *>(editor);
     colorWidget->SetColor(data.value<QColor>());
   }
   else
   {
     QStyledItemDelegate::setEditorData(editor, index);
   }
 }
 
 void QmitkPropertyItemDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
 {
   QVariant data = index.data(Qt::EditRole);
 
   if (!data.isValid())
     return;
 
   if (data.type() == QVariant::Int)
   {
     QSpinBox *spinBox = qobject_cast<QSpinBox *>(editor);
     model->setData(index, spinBox->value());
   }
   else if (data.type() == QVariant::Double)
   {
     QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(editor);
     model->setData(index, spinBox->value());
   }
   else if (static_cast<QMetaType::Type>(data.type()) == QMetaType::Float)
   {
     QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(editor);
     model->setData(index, static_cast<float>(spinBox->value()));
   }
   else if (data.type() == QVariant::StringList)
   {
     QComboBox *comboBox = qobject_cast<QComboBox *>(editor);
     model->setData(index, comboBox->currentText());
   }
   else if (data.type() == QVariant::Color)
   {
     QmitkColorWidget *colorWidget = qobject_cast<QmitkColorWidget *>(editor);
     model->setData(index, colorWidget->GetColor());
   }
   else
   {
     QStyledItemDelegate::setModelData(editor, model, index);
   }
 }
 
 void QmitkPropertyItemDelegate::SetPropertyList(mitk::PropertyList *propertyList)
 {
   if (m_PropertyList != propertyList)
     m_PropertyList = propertyList;
 }
diff --git a/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp b/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp
index 66b89810ff..10514fbe2a 100644
--- a/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp
+++ b/Modules/QtWidgets/src/QmitkPropertyItemModel.cpp
@@ -1,474 +1,478 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkPropertyItemModel.h"
 #include "QmitkPropertyItem.h"
 #include <QColor>
 #include <mitkColorProperty.h>
 #include <mitkEnumerationProperty.h>
 #include <mitkIPropertyAliases.h>
 #include <mitkIPropertyFilters.h>
 #include <mitkProperties.h>
 #include <mitkRenderingManager.h>
 #include <mitkStringProperty.h>
 
 namespace
 {
   QColor MitkToQt(const mitk::Color& color)
   {
     return QColor(color.GetRed() * 255, color.GetGreen() * 255, color.GetBlue() * 255);
   }
 
   mitk::BaseProperty* GetBaseProperty(const QVariant& data)
   {
     return data.isValid() ? reinterpret_cast<mitk::BaseProperty*>(data.value<void*>()) : nullptr;
   }
 
   mitk::Color QtToMitk(const QColor& color)
   {
     mitk::Color mitkColor;
 
     mitkColor.SetRed(color.red() / 255.0f);
     mitkColor.SetGreen(color.green() / 255.0f);
     mitkColor.SetBlue(color.blue() / 255.0f);
 
     return mitkColor;
   }
 }
 
 class PropertyEqualTo
 {
 public:
   PropertyEqualTo(const mitk::BaseProperty *property) : m_Property(property) {}
   bool operator()(const mitk::PropertyList::PropertyMapElementType &pair) const
   {
     return pair.second.GetPointer() == m_Property;
   }
 
 private:
   const mitk::BaseProperty *m_Property;
 };
 
 QmitkPropertyItemModel::QmitkPropertyItemModel(QObject *parent)
   : QAbstractItemModel(parent),
     m_PropertyAliases(mitk::CoreServices::GetPropertyAliases()),
     m_PropertyFilters(mitk::CoreServices::GetPropertyFilters())
 {
   this->CreateRootItem();
 }
 
 QmitkPropertyItemModel::~QmitkPropertyItemModel()
 {
   this->SetNewPropertyList(nullptr);
 }
 
 int QmitkPropertyItemModel::columnCount(const QModelIndex &parent) const
 {
   if (parent.isValid())
     return static_cast<QmitkPropertyItem *>(parent.internalPointer())->GetColumnCount();
   else
     return m_RootItem->GetColumnCount();
 }
 
 void QmitkPropertyItemModel::CreateRootItem()
 {
   QList<QVariant> rootData;
   rootData << "Property"
            << "Value";
 
   m_RootItem.reset(new QmitkPropertyItem(rootData));
 
   this->beginResetModel();
   this->endResetModel();
 }
 
 QVariant QmitkPropertyItemModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid())
     return QVariant();
 
   mitk::BaseProperty *property =
     index.column() == 1 ? GetBaseProperty(static_cast<QmitkPropertyItem *>(index.internalPointer())->GetData(1)) : nullptr;
 
   if (role == Qt::DisplayRole)
   {
     if (index.column() == 0)
     {
       return static_cast<QmitkPropertyItem *>(index.internalPointer())->GetData(0);
     }
     else if (index.column() == 1 && property != nullptr)
     {
       if (auto colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
         return MitkToQt(colorProperty->GetValue());
       else if (dynamic_cast<mitk::BoolProperty *>(property) == nullptr)
         return QString::fromStdString(property->GetValueAsString());
     }
   }
   else if (index.column() == 1 && property != nullptr)
   {
     if (role == Qt::CheckStateRole)
     {
       if (auto boolProperty = dynamic_cast<mitk::BoolProperty *>(property))
         return boolProperty->GetValue() ? Qt::Checked : Qt::Unchecked;
     }
     else if (role == Qt::EditRole)
     {
       if (dynamic_cast<mitk::StringProperty *>(property) != nullptr)
       {
         return QString::fromStdString(property->GetValueAsString());
       }
       else if (auto intProperty = dynamic_cast<mitk::IntProperty *>(property))
       {
         return intProperty->GetValue();
       }
       else if (auto floatProperty = dynamic_cast<mitk::FloatProperty *>(property))
       {
         return floatProperty->GetValue();
       }
       else if (auto doubleProperty = dynamic_cast<mitk::DoubleProperty *>(property))
       {
         return doubleProperty->GetValue();
       }
       else if (auto enumProperty = dynamic_cast<mitk::EnumerationProperty *>(property))
       {
         QStringList values;
 
         for (mitk::EnumerationProperty::EnumConstIterator it = enumProperty->Begin(); it != enumProperty->End(); it++)
           values << QString::fromStdString(it->second);
 
         return values;
       }
       else if (auto colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
       {
         return MitkToQt(colorProperty->GetValue());
       }
     }
     else if (role == mitk::PropertyRole)
     {
       return QVariant::fromValue<void *>(property);
     }
   }
 
   return QVariant();
 }
 
 QModelIndex QmitkPropertyItemModel::FindProperty(const mitk::BaseProperty *property)
 {
   if (property == nullptr)
     return QModelIndex();
 
-  if (m_PropertyList.IsExpired())
+  auto propertyList = m_PropertyList.Lock();
+
+  if (propertyList.IsNull())
     return QModelIndex();
 
-  auto propertyMap = m_PropertyList.Lock()->GetMap();
+  auto propertyMap = propertyList->GetMap();
   auto it = std::find_if(propertyMap->begin(), propertyMap->end(), PropertyEqualTo(property));
 
   if (it == propertyMap->end())
     return QModelIndex();
 
   QString name = QString::fromStdString(it->first);
 
   if (!name.contains('.'))
   {
     QModelIndexList item = this->match(index(0, 0), Qt::DisplayRole, name, 1, Qt::MatchExactly);
 
     if (!item.empty())
       return item[0];
   }
   else
   {
     QStringList names = name.split('.');
     QModelIndexList items =
       this->match(index(0, 0), Qt::DisplayRole, names.last(), -1, Qt::MatchRecursive | Qt::MatchExactly);
 
     for (auto item : qAsConst(items))
     {
       QModelIndex candidate = item;
 
       for (int i = names.length() - 1; i != 0; --i)
       {
         QModelIndex parent = item.parent();
 
         if (parent.parent() == QModelIndex())
         {
           if (parent.data() != names.first())
             break;
 
           return candidate;
         }
 
         if (parent.data() != names[i - 1])
           break;
 
         item = parent;
       }
     }
   }
 
   return QModelIndex();
 }
 
 Qt::ItemFlags QmitkPropertyItemModel::flags(const QModelIndex &index) const
 {
   Qt::ItemFlags flags = QAbstractItemModel::flags(index);
 
   if (index.column() == 1)
   {
     if (index.data(Qt::EditRole).isValid())
       flags |= Qt::ItemIsEditable;
 
     if (index.data(Qt::CheckStateRole).isValid())
       flags |= Qt::ItemIsUserCheckable;
   }
 
   return flags;
 }
 
 mitk::PropertyList *QmitkPropertyItemModel::GetPropertyList() const
 {
   return m_PropertyList.Lock().GetPointer();
 }
 
 QVariant QmitkPropertyItemModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
     return m_RootItem->GetData(section);
 
   return QVariant();
 }
 
 QModelIndex QmitkPropertyItemModel::index(int row, int column, const QModelIndex &parent) const
 {
   if (!this->hasIndex(row, column, parent))
     return QModelIndex();
 
   QmitkPropertyItem *parentItem =
     parent.isValid() ? static_cast<QmitkPropertyItem *>(parent.internalPointer()) : m_RootItem.get();
 
   QmitkPropertyItem *childItem = parentItem->GetChild(row);
 
   return childItem != nullptr ? this->createIndex(row, column, childItem) : QModelIndex();
 }
 
 void QmitkPropertyItemModel::OnPropertyListModified()
 {
   this->SetNewPropertyList(m_PropertyList.Lock());
 }
 
 void QmitkPropertyItemModel::OnPropertyListDeleted()
 {
   this->CreateRootItem();
 }
 
 void QmitkPropertyItemModel::OnPropertyModified(const itk::Object *property, const itk::EventObject &)
 {
   QModelIndex index = this->FindProperty(static_cast<const mitk::BaseProperty *>(property));
 
   if (index != QModelIndex())
     emit dataChanged(index, index);
 }
 
 QModelIndex QmitkPropertyItemModel::parent(const QModelIndex &child) const
 {
   if (!child.isValid())
     return QModelIndex();
 
   QmitkPropertyItem *parentItem = static_cast<QmitkPropertyItem *>(child.internalPointer())->GetParent();
 
   if (parentItem == m_RootItem.get())
     return QModelIndex();
 
   return this->createIndex(parentItem->GetRow(), 0, parentItem);
 }
 
 int QmitkPropertyItemModel::rowCount(const QModelIndex &parent) const
 {
   if (parent.column() > 0)
     return 0;
 
   QmitkPropertyItem *parentItem =
     parent.isValid() ? static_cast<QmitkPropertyItem *>(parent.internalPointer()) : m_RootItem.get();
 
   return parentItem->GetChildCount();
 }
 
 bool QmitkPropertyItemModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
   if (!index.isValid() || index.column() != 1 || (role != Qt::EditRole && role != Qt::CheckStateRole))
     return false;
 
   mitk::BaseProperty *property = GetBaseProperty(static_cast<QmitkPropertyItem *>(index.internalPointer())->GetData(1));
 
   if (property == nullptr)
     return false;
 
   if (mitk::BoolProperty *boolProperty = dynamic_cast<mitk::BoolProperty *>(property))
   {
     boolProperty->SetValue(value.toInt() == Qt::Checked ? true : false);
   }
   else if (mitk::StringProperty *stringProperty = dynamic_cast<mitk::StringProperty *>(property))
   {
     stringProperty->SetValue(value.toString().toStdString());
   }
   else if (mitk::IntProperty *intProperty = dynamic_cast<mitk::IntProperty *>(property))
   {
     intProperty->SetValue(value.toInt());
   }
   else if (mitk::FloatProperty *floatProperty = dynamic_cast<mitk::FloatProperty *>(property))
   {
     floatProperty->SetValue(value.toFloat());
   }
   else if (mitk::DoubleProperty *doubleProperty = dynamic_cast<mitk::DoubleProperty *>(property))
   {
     doubleProperty->SetValue(value.toDouble());
   }
   else if (mitk::EnumerationProperty *enumProperty = dynamic_cast<mitk::EnumerationProperty *>(property))
   {
     std::string selection = value.toString().toStdString();
 
     if (selection != enumProperty->GetValueAsString() && enumProperty->IsValidEnumerationValue(selection))
       enumProperty->SetValue(selection);
   }
   else if (mitk::ColorProperty *colorProperty = dynamic_cast<mitk::ColorProperty *>(property))
   {
     colorProperty->SetValue(QtToMitk(value.value<QColor>()));
   }
 
   auto propertyList = m_PropertyList.Lock();
 
   propertyList->Modified();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   return true;
 }
 
 void QmitkPropertyItemModel::SetNewPropertyList(mitk::PropertyList *newPropertyList)
 {
   typedef mitk::PropertyList::PropertyMap PropertyMap;
 
   this->beginResetModel();
 
-  if (!m_PropertyList.IsExpired())
-  {
-    auto propertyList = m_PropertyList.Lock();
+  auto propertyList = m_PropertyList.Lock();
 
+  if (propertyList.IsNotNull())
+  {
     propertyList->RemoveObserver(m_PropertyListDeletedTag);
     propertyList->RemoveObserver(m_PropertyListModifiedTag);
 
-    const PropertyMap *propertyMap = m_PropertyList.Lock()->GetMap();
+    const PropertyMap *propertyMap = propertyList->GetMap();
 
     for (PropertyMap::const_iterator propertyIt = propertyMap->begin(); propertyIt != propertyMap->end(); ++propertyIt)
     {
       std::map<std::string, unsigned long>::const_iterator tagIt = m_PropertyModifiedTags.find(propertyIt->first);
 
       if (tagIt != m_PropertyModifiedTags.end())
         propertyIt->second->RemoveObserver(tagIt->second);
 
       tagIt = m_PropertyDeletedTags.find(propertyIt->first);
 
       if (tagIt != m_PropertyDeletedTags.end())
         propertyIt->second->RemoveObserver(tagIt->second);
     }
 
     m_PropertyModifiedTags.clear();
     m_PropertyDeletedTags.clear();
   }
 
   m_PropertyList = newPropertyList;
+  propertyList = m_PropertyList.Lock();
 
-  if (!m_PropertyList.IsExpired())
+  if (propertyList.IsNotNull())
   {
     auto onPropertyListModified = itk::SimpleMemberCommand<QmitkPropertyItemModel>::New();
     onPropertyListModified->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyListModified);
-    m_PropertyListModifiedTag = m_PropertyList.Lock()->AddObserver(itk::ModifiedEvent(), onPropertyListModified);
+    m_PropertyListModifiedTag = propertyList->AddObserver(itk::ModifiedEvent(), onPropertyListModified);
 
     auto onPropertyListDeleted = itk::SimpleMemberCommand<QmitkPropertyItemModel>::New();
     onPropertyListDeleted->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyListDeleted);
-    m_PropertyListDeletedTag = m_PropertyList.Lock()->AddObserver(itk::DeleteEvent(), onPropertyListDeleted);
+    m_PropertyListDeletedTag = propertyList->AddObserver(itk::DeleteEvent(), onPropertyListDeleted);
 
     auto modifiedCommand = itk::MemberCommand<QmitkPropertyItemModel>::New();
     modifiedCommand->SetCallbackFunction(this, &QmitkPropertyItemModel::OnPropertyModified);
 
     const PropertyMap *propertyMap = m_PropertyList.Lock()->GetMap();
 
     for (PropertyMap::const_iterator it = propertyMap->begin(); it != propertyMap->end(); ++it)
       m_PropertyModifiedTags.insert(
         std::make_pair(it->first, it->second->AddObserver(itk::ModifiedEvent(), modifiedCommand)));
   }
 
   this->CreateRootItem();
+  propertyList = m_PropertyList.Lock();
 
-  if (m_PropertyList != nullptr && !m_PropertyList.Lock()->IsEmpty())
+  if (propertyList.IsNotNull() && !propertyList->IsEmpty())
   {
     mitk::PropertyList::PropertyMap filteredProperties;
     bool filterProperties = false;
 
     if (m_PropertyFilters->HasFilter() || m_PropertyFilters->HasFilter(m_ClassName.toStdString()))
     {
-      filteredProperties = m_PropertyFilters->ApplyFilter(*m_PropertyList.Lock()->GetMap(), m_ClassName.toStdString());
+      filteredProperties = m_PropertyFilters->ApplyFilter(*propertyList->GetMap(), m_ClassName.toStdString());
       filterProperties = true;
     }
 
     const mitk::PropertyList::PropertyMap *propertyMap =
-      !filterProperties ? m_PropertyList.Lock()->GetMap() : &filteredProperties;
+      !filterProperties ? propertyList->GetMap() : &filteredProperties;
 
     mitk::PropertyList::PropertyMap::const_iterator end = propertyMap->end();
 
     for (mitk::PropertyList::PropertyMap::const_iterator iter = propertyMap->begin(); iter != end; ++iter)
     {
       std::vector<std::string> aliases;
 
       aliases = m_PropertyAliases->GetAliases(iter->first, m_ClassName.toStdString());
 
       if (aliases.empty() && !m_ClassName.isEmpty())
         aliases = m_PropertyAliases->GetAliases(iter->first);
 
       if (aliases.empty())
       {
         QList<QVariant> data;
         data << QString::fromStdString(iter->first)
              << QVariant::fromValue((reinterpret_cast<void *>(iter->second.GetPointer())));
 
         m_RootItem->AppendChild(new QmitkPropertyItem(data));
       }
       else
       {
         std::vector<std::string>::const_iterator end = aliases.end();
         for (std::vector<std::string>::const_iterator aliasIter = aliases.begin(); aliasIter != end; ++aliasIter)
         {
           QList<QVariant> data;
           data << QString::fromStdString(*aliasIter)
                << QVariant::fromValue((reinterpret_cast<void *>(iter->second.GetPointer())));
 
           m_RootItem->AppendChild(new QmitkPropertyItem(data));
         }
       }
     }
   }
 
   this->endResetModel();
 }
 
 void QmitkPropertyItemModel::SetPropertyList(mitk::PropertyList *propertyList, const QString &className)
 {
   if (m_PropertyList != propertyList)
   {
     m_ClassName = className;
     this->SetNewPropertyList(propertyList);
   }
 }
 
 void QmitkPropertyItemModel::Update()
 {
   this->SetNewPropertyList(m_PropertyList.Lock());
 }
diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index 57d17f093c..0f67cfc350 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,808 +1,808 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #define SMW_INFO MITK_INFO("widget.stdmulti")
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkRenderWindowWidget.h"
 
 // mitk core
 #include <mitkCameraController.h>
 #include <mitkImage.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkInteractionConst.h>
 #include <mitkLine.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkPlaneGeometryDataMapper2D.h>
 #include <mitkPointSet.h>
 #include <mitkProperties.h>
 #include <mitkStatusBar.h>
 #include <mitkDisplayActionEventHandlerStd.h>
 #include <mitkVtkLayerController.h>
 
 // qt
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 
 // vtk
 #include <vtkSmartPointer.h>
 
 // c++
 #include <iomanip>
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
                                          Qt::WindowFlags f/* = 0*/,
                                          const QString &name/* = "stdmulti"*/)
   : QmitkAbstractMultiWidget(parent, f, name)
   , m_TimeNavigationController(nullptr)
   , m_PendingCrosshairPositionEvent(false)
 {
   m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
 }
 
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   auto allRenderWindows = this->GetRenderWindows();
   for (auto& renderWindow : allRenderWindows)
   {
     m_TimeNavigationController->Disconnect(renderWindow->GetSliceNavigationController());
   }
 }
 
 void QmitkStdMultiWidget::InitializeMultiWidget()
 {
   // yellow is default color for widget4
   m_DecorationColorWidget4[0] = 1.0f;
   m_DecorationColorWidget4[1] = 1.0f;
   m_DecorationColorWidget4[2] = 0.0f;
 
   SetLayout(2, 2);
 
   // transfer colors in WorldGeometry-Nodes of the associated Renderer
   mitk::IntProperty::Pointer layer;
   // of widget 1
   m_PlaneNode1 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetColor(GetDecorationColor(0));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode1->SetProperty("layer", layer);
 
   // of widget 2
   m_PlaneNode2 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetColor(GetDecorationColor(1));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode2->SetProperty("layer", layer);
 
   // of widget 3
   m_PlaneNode3 =
     mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetColor(GetDecorationColor(2));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode3->SetProperty("layer", layer);
 
   // the parent node
   m_ParentNodeForGeometryPlanes =
     mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
   layer = mitk::IntProperty::New(1000);
   m_ParentNodeForGeometryPlanes->SetProperty("layer", layer);
 
   AddDisplayPlaneSubTree();
 
   SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerStd>());
 
   auto displayActionEventHandler = GetDisplayActionEventHandler();
   if (nullptr != displayActionEventHandler)
   {
     displayActionEventHandler->InitActions();
   }
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const QString& widgetName) const
 {
   if ("axial" == widgetName)
   {
     return GetRenderWindow1();
   }
 
   if ("sagittal" == widgetName)
   {
     return GetRenderWindow2();
   }
 
   if ("coronal" == widgetName)
   {
     return GetRenderWindow3();
   }
 
   if ("3d" == widgetName)
   {
     return GetRenderWindow4();
   }
 
 
   return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const
 {
   return GetRenderWindow(static_cast<unsigned int>(viewDirection));
 }
 
 void QmitkStdMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& /*widgetName*/)
 {
   GetRenderWindow1()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   GetRenderWindow2()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   GetRenderWindow3()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
 
   RequestUpdateAll();
 }
 
 const mitk::Point3D QmitkStdMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
 {
   const mitk::PlaneGeometry* plane1 = GetRenderWindow1()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry* plane2 = GetRenderWindow2()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry* plane3 = GetRenderWindow3()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ((plane1 != nullptr) && (plane2 != nullptr)
    && (plane1->IntersectionLine(plane2, line)))
   {
     mitk::Point3D point;
     if ((plane3 != nullptr) && (plane3->IntersectionPoint(line, point)))
     {
       return point;
     }
   }
 
   return mitk::Point3D();
 }
 
 void QmitkStdMultiWidget::SetCrosshairVisibility(bool visible)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible);
   }
 
   emit NotifyCrosshairVisibilityChanged(visible);
 
   RequestUpdateAll();
 }
 
 bool QmitkStdMultiWidget::GetCrosshairVisibility() const
 {
   bool crosshairVisibility = true;
 
   if (m_PlaneNode1.IsNotNull())
   {
     bool visibilityProperty = false;
     m_PlaneNode1->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   if (m_PlaneNode2.IsNotNull())
   {
     bool visibilityProperty = false;
     crosshairVisibility &= m_PlaneNode2->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   if (m_PlaneNode3.IsNotNull())
   {
     bool visibilityProperty = false;
     crosshairVisibility &= m_PlaneNode3->GetVisibility(visibilityProperty, nullptr);
     crosshairVisibility &= visibilityProperty;
   }
 
   return crosshairVisibility;
 }
 
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
 
   SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   switch (userMode)
   {
   case 0:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKStandard);
     break;
   case 1:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationUncoupled);
     break;
   case 2:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationCoupled);
     break;
   case 3:
     SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKSwivel);
     break;
   }
 
   emit NotifyCrosshairRotationModeChanged(userMode);
 }
 
 mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 void QmitkStdMultiWidget::AddPlanesToDataStorage()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
    && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     dataStorage->Add(m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
     dataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
   }
 }
 
 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
    && m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     dataStorage->Remove(m_PlaneNode1);
     dataStorage->Remove(m_PlaneNode2);
     dataStorage->Remove(m_PlaneNode3);
     dataStorage->Remove(m_ParentNodeForGeometryPlanes);
   }
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
 {
   if (!m_PendingCrosshairPositionEvent)
   {
     m_PendingCrosshairPositionEvent = true;
     QTimer::singleShot(0, this, SLOT(HandleCrosshairPositionEventDelayed()));
   }
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(unsigned int number) const
 {
   switch (number)
   {
   case 0:
     return GetRenderWindow1();
   case 1:
     return GetRenderWindow2();
   case 2:
     return GetRenderWindow3();
   case 3:
     return GetRenderWindow4();
   default:
     MITK_ERROR << "Requested unknown render window";
     break;
   }
 
   return nullptr;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 0));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 1));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 0));
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
 {
   return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 1));
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1() const
 {
   return m_PlaneNode1;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2() const
 {
   return m_PlaneNode2;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3() const
 {
   return m_PlaneNode3;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(unsigned number) const
 {
   switch (number)
   {
   case 1:
     return m_PlaneNode1;
   case 2:
     return m_PlaneNode2;
   case 3:
     return m_PlaneNode3;
   default:
     MITK_ERROR << "Requested unknown render window";
     break;
   }
 
   return nullptr;
 }
 
 void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
 {
   switch (widgetNumber)
   {
   case 0:
     if (m_PlaneNode1.IsNotNull())
     {
       m_PlaneNode1->SetColor(color);
     }
     break;
   case 1:
     if (m_PlaneNode2.IsNotNull())
     {
       m_PlaneNode2->SetColor(color);
     }
     break;
   case 2:
     if (m_PlaneNode3.IsNotNull())
     {
       m_PlaneNode3->SetColor(color);
     }
     break;
   case 3:
     m_DecorationColorWidget4 = color;
     break;
   default:
     MITK_ERROR << "Decoration color for unknown widget!";
     break;
   }
 }
 
 mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber)
 {
   // The implementation looks a bit messy here, but it avoids
   // synchronization of the color of the geometry nodes and an
   // internal member here.
   // Default colors were chosen for decent visibility.
   // Feel free to change your preferences in the workbench.
   float tmp[3] = { 0.0f, 0.0f, 0.0f };
   switch (widgetNumber)
   {
   case 0:
   {
     if (m_PlaneNode1.IsNotNull())
     {
       if (m_PlaneNode1->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode1->GetProperty("color"))->GetColor();
       }
     }
     float red[3] = { 0.753f, 0.0f, 0.0f }; // This is #C00000 in hex
     return mitk::Color(red);
   }
   case 1:
   {
     if (m_PlaneNode2.IsNotNull())
     {
       if (m_PlaneNode2->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode2->GetProperty("color"))->GetColor();
       }
     }
     float green[3] = { 0.0f, 0.69f, 0.0f }; // This is #00B000 in hex
     return mitk::Color(green);
   }
   case 2:
   {
     if (m_PlaneNode3.IsNotNull())
     {
       if (m_PlaneNode3->GetColor(tmp))
       {
         return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode3->GetProperty("color"))->GetColor();
       }
     }
     float blue[3] = { 0.0, 0.502f, 1.0f }; // This is #0080FF in hex
     return mitk::Color(blue);
   }
   case 3:
   {
     return m_DecorationColorWidget4;
   }
   default:
     MITK_ERROR << "Decoration color for unknown widget!";
     float black[3] = { 0.0f, 0.0f, 0.0f };
     return mitk::Color(black);
   }
 }
 
 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent*)
 {
   // nothing here, but necessary for mouse interactions (.xml-configuration files)
 }
 
 void QmitkStdMultiWidget::moveEvent(QMoveEvent* e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the Annotation as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 void QmitkStdMultiWidget::wheelEvent(QWheelEvent* e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
 {
   auto dataStorage = GetDataStorage();
   if (nullptr == dataStorage)
   {
     return;
   }
 
   m_PendingCrosshairPositionEvent = false;
 
   // find image with highest layer
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = dataStorage->GetSubset(isImageData).GetPointer();
   mitk::Point3D crosshairPos = GetSelectedPosition("");
   mitk::BaseRenderer* baseRenderer = GetRenderWindow1()->GetSliceNavigationController()->GetRenderer();
   auto globalCurrentTimePoint = baseRenderer->GetTime();
   mitk::DataNode::Pointer node = mitk::FindTopmostVisibleNode(nodes, crosshairPos, globalCurrentTimePoint, baseRenderer);
 
   mitk::DataNode::Pointer topSourceNode;
   mitk::Image::Pointer image;
   bool isBinary = false;
   int component = 0;
 
   if (node.IsNotNull())
   {
     node->GetBoolProperty("binary", isBinary);
     if (isBinary)
     {
       mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = dataStorage->GetSources(node, nullptr, true);
       if (!sourcenodes->empty())
       {
         topSourceNode = mitk::FindTopmostVisibleNode(sourcenodes, crosshairPos, globalCurrentTimePoint, baseRenderer);
       }
       if (topSourceNode.IsNotNull())
       {
         image = dynamic_cast<mitk::Image *>(topSourceNode->GetData());
         topSourceNode->GetIntProperty("Image.Displayed Component", component);
       }
       else
       {
         image = dynamic_cast<mitk::Image *>(node->GetData());
         node->GetIntProperty("Image.Displayed Component", component);
       }
     }
     else
     {
       image = dynamic_cast<mitk::Image *>(node->GetData());
       node->GetIntProperty("Image.Displayed Component", component);
     }
   }
 
   std::string statusText;
   std::stringstream stream;
   itk::Index<3> p;
   unsigned int timestep = baseRenderer->GetTimeStep();
 
   if (image.IsNotNull() && (image->GetTimeSteps() > timestep))
   {
     image->GetGeometry()->WorldToIndex(crosshairPos, p);
     stream.precision(2);
     stream << "Position: <" << std::fixed << crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", "
       << std::fixed << crosshairPos[2] << "> mm";
     stream << "; Index: <" << p[0] << ", " << p[1] << ", " << p[2] << "> ";
 
     mitk::ScalarType pixelValue;
 
     mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess,
       image->GetChannelDescriptor().GetPixelType(),
       image,
       image->GetVolumeData(image->GetTimeGeometry()->TimePointToTimeStep(globalCurrentTimePoint)),
       p,
       pixelValue,
       component);
 
     if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
     {
       stream << "; Time: " << globalCurrentTimePoint << " ms; Pixelvalue: " << std::scientific << pixelValue << "  ";
     }
     else
     {
       stream << "; Time: " << globalCurrentTimePoint << " ms; Pixelvalue: " << pixelValue << "  ";
     }
   }
   else
   {
     stream << "No image information at this position!";
   }
 
   statusText = stream.str();
   mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
 }
 
 void QmitkStdMultiWidget::Fit()
 {
   vtkSmartPointer<vtkRenderer> vtkrenderer;
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetVtkRenderer();
   if (nullptr != vtkrenderer)
   {
     vtkrenderer->ResetCamera();
   }
 
   mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetCameraController()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
 {
   // add the displayed planes of the multiwidget to a node to which the subtree
   // @a planesSubTree points ...
 
   mitk::PlaneGeometryDataMapper2D::Pointer mapper;
 
   // ... of widget 1
   mitk::BaseRenderer* renderer1 = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow());
   m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane"));
   m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   mitk::BaseRenderer* renderer2 = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow());
   m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane"));
   m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow());
   m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane"));
   m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   m_ParentNodeForGeometryPlanes = mitk::DataNode::New();
   m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets"));
   m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true));
 }
 
 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
 {
   mitk::Point2D pointOnDisplay;
   renderer->WorldToDisplay(p, pointOnDisplay);
 
   if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] ||
     pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] ||
     pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] ||
     pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1])
   {
     mitk::Point2D pointOnPlane;
     renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane);
     renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane);
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
 {
   auto dataStorage = GetDataStorage();
   if (nullptr != dataStorage)
   {
     mitk::DataNode* dataNode = dataStorage->GetNamedNode(widgetName);
     if (dataNode != nullptr)
     {
       dataNode->SetVisibility(visible, renderer);
     }
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible, renderer);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PRIVATE
 //////////////////////////////////////////////////////////////////////////
 void QmitkStdMultiWidget::SetLayoutImpl()
 {
   CreateRenderWindowWidgets();
   GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
 
   // Initialize views as axial, sagittal, coronal to all data objects in DataStorage
   auto geo = GetDataStorage()->ComputeBoundingGeometry3D(GetDataStorage()->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 }
 
 void QmitkStdMultiWidget::CreateRenderWindowWidgets()
 {
   // create axial render window (widget)
   QString renderWindowWidgetName = GetNameFromIndex(0, 0);
   RenderWindowWidgetPointer renderWindowWidget1 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow1 = renderWindowWidget1->GetRenderWindow();
   renderWindow1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
   renderWindowWidget1->SetDecorationColor(GetDecorationColor(0));
   renderWindowWidget1->SetCornerAnnotationText("Axial");
   renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(ViewDirection::AXIAL);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget1);
 
   // create sagittal render window (widget)
   renderWindowWidgetName = GetNameFromIndex(0, 1);
   RenderWindowWidgetPointer renderWindowWidget2 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow2 = renderWindowWidget2->GetRenderWindow();
   renderWindow2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
   renderWindowWidget2->SetDecorationColor(GetDecorationColor(1));
   renderWindowWidget2->setStyleSheet("border: 0px");
   renderWindowWidget2->SetCornerAnnotationText("Sagittal");
   renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(ViewDirection::SAGITTAL);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget2);
 
   // create coronal render window (widget)
   renderWindowWidgetName = GetNameFromIndex(1, 0);
   RenderWindowWidgetPointer renderWindowWidget3 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow3 = renderWindowWidget3->GetRenderWindow();
-  renderWindow3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
+  renderWindow3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Coronal);
   renderWindowWidget3->SetDecorationColor(GetDecorationColor(2));
   renderWindowWidget3->SetCornerAnnotationText("Coronal");
   renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(ViewDirection::CORONAL);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget3);
 
   // create 3D render window (widget)
   renderWindowWidgetName = GetNameFromIndex(1, 1);
   RenderWindowWidgetPointer renderWindowWidget4 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
   auto renderWindow4 = renderWindowWidget4->GetRenderWindow();
   renderWindow4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
   renderWindowWidget4->SetDecorationColor(GetDecorationColor(3));
   renderWindowWidget4->SetCornerAnnotationText("3D");
   renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(ViewDirection::THREE_D);
   mitk::BaseRenderer::GetInstance(renderWindowWidget4->GetRenderWindow()->renderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget4);
 
   SetActiveRenderWindowWidget(renderWindowWidget1);
 
   // connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow1->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow2->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow3->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow4->GetSliceNavigationController(), false);
   renderWindow1->GetSliceNavigationController()->ConnectGeometrySendEvent(
     mitk::BaseRenderer::GetInstance(renderWindow4->renderWindow()));
 
   // reverse connection between sliceNavigationControllers and timeNavigationController
   renderWindow1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   renderWindow2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   renderWindow3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   //renderWindow4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
 
   auto layoutManager = GetMultiWidgetLayoutManager();
   connect(renderWindow1, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow1, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow1, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow1, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow1, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow1, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow2, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow2, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow2, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow2, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow2, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow2, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow3, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow3, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow3, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow3, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow3, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow3, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 
   connect(renderWindow4, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
   connect(renderWindow4, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
   connect(renderWindow4, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
   connect(renderWindow4, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow4, &QmitkRenderWindow::UpdateCrosshairVisibility);
   connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow4, &QmitkRenderWindow::UpdateCrosshairRotationMode);
 }
diff --git a/Modules/QtWidgetsExt/files.cmake b/Modules/QtWidgetsExt/files.cmake
index e8bd9dd1f6..d5b2255af4 100644
--- a/Modules/QtWidgetsExt/files.cmake
+++ b/Modules/QtWidgetsExt/files.cmake
@@ -1,106 +1,104 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   qclickablelabel.cpp
   QmitkAboutDialog.cpp
   QmitkBasePropertyView.cpp
   QmitkBoolPropertyWidget.cpp
   QmitkBoundingObjectWidget.cpp
   QmitkCallbackFromGUIThread.cpp
   QmitkColorPropertyEditor.cpp
   QmitkColorPropertyView.cpp
   QmitkColorTransferFunctionCanvas.cpp
   QmitkCrossWidget.cpp
   QmitkEditPointDialog.cpp
   QmitkEnumerationPropertyWidget.cpp
   QmitkFFmpegWriter.cpp
   QmitkFileChooser.cpp
   QmitkGnuplotWidget.cpp
   QmitkHistogram.cpp
   QmitkHotkeyLineEdit.cpp
   QmitkModulesDialog.cpp
   QmitkModuleTableModel.cpp
   QmitkNumberPropertyEditor.cpp
   QmitkNumberPropertySlider.cpp
   QmitkNumberPropertyView.cpp
   QmitkPiecewiseFunctionCanvas.cpp
   QmitkPlotDialog.cpp
   QmitkPlotWidget.cpp
   QmitkPointListModel.cpp
   QmitkPointListView.cpp
-  QmitkPointListViewWidget.cpp
   QmitkPointListWidget.cpp
   QmitkPrimitiveMovieNavigatorWidget.cpp
   QmitkPropertyViewFactory.cpp
   QmitkSelectableGLWidget.cpp
   QmitkSliceWidget.cpp
   QmitkSliderNavigatorWidget.cpp
   QmitkStandardViews.cpp
   QmitkStepperAdapter.cpp
   QmitkStringPropertyEditor.cpp
   QmitkStringPropertyOnDemandEdit.cpp
   QmitkStringPropertyView.cpp
   QmitkTransferFunctionCanvas.cpp
   QmitkTransferFunctionGeneratorWidget.cpp
   QmitkTransferFunctionWidget.cpp
   QmitkUGCombinedRepresentationPropertyWidget.cpp
   QmitkVideoBackground.cpp
   QtWidgetsExtRegisterClasses.cpp
 )
 
 set(MOC_H_FILES
   include/qclickablelabel.h
   include/QmitkAboutDialog.h
   include/QmitkBasePropertyView.h
   include/QmitkBoolPropertyWidget.h
   include/QmitkBoundingObjectWidget.h
   include/QmitkCallbackFromGUIThread.h
   include/QmitkColorPropertyEditor.h
   include/QmitkColorPropertyView.h
   include/QmitkColorTransferFunctionCanvas.h
   include/QmitkCrossWidget.h
   include/QmitkEditPointDialog.h
   include/QmitkEnumerationPropertyWidget.h
   include/QmitkFFmpegWriter.h
   include/QmitkFileChooser.h
   include/QmitkGnuplotWidget.h
   include/QmitkHotkeyLineEdit.h
   include/QmitkNumberPropertyEditor.h
   include/QmitkNumberPropertySlider.h
   include/QmitkNumberPropertyView.h
   include/QmitkPiecewiseFunctionCanvas.h
   include/QmitkPlotWidget.h
   include/QmitkPointListModel.h
   include/QmitkPointListView.h
-  include/QmitkPointListViewWidget.h
   include/QmitkPointListWidget.h
   include/QmitkPrimitiveMovieNavigatorWidget.h
   include/QmitkSelectableGLWidget.h
   include/QmitkSliceWidget.h
   include/QmitkSliderNavigatorWidget.h
   include/QmitkStandardViews.h
   include/QmitkStepperAdapter.h
   include/QmitkStringPropertyEditor.h
   include/QmitkStringPropertyOnDemandEdit.h
   include/QmitkStringPropertyView.h
   include/QmitkTransferFunctionCanvas.h
   include/QmitkTransferFunctionGeneratorWidget.h
   include/QmitkTransferFunctionWidget.h
   include/QmitkUGCombinedRepresentationPropertyWidget.h
   include/QmitkVideoBackground.h
 )
 
 set(UI_FILES
   src/QmitkAboutDialogGUI.ui
   src/QmitkGnuplotWidget.ui
   src/QmitkPrimitiveMovieNavigatorWidget.ui
   src/QmitkSelectableGLWidget.ui
   src/QmitkSliceWidget.ui
   src/QmitkSliderNavigator.ui
   src/QmitkTransferFunctionGeneratorWidget.ui
   src/QmitkTransferFunctionWidget.ui
 )
 
 set(QRC_FILES
   resource/QtWidgetsExt.qrc
 )
diff --git a/Modules/QtWidgetsExt/include/QmitkPointListView.h b/Modules/QtWidgetsExt/include/QmitkPointListView.h
index fccb80b0b4..7dcc2b309e 100644
--- a/Modules/QtWidgetsExt/include/QmitkPointListView.h
+++ b/Modules/QtWidgetsExt/include/QmitkPointListView.h
@@ -1,120 +1,124 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITK_POINTLIST_VIEW_H_INCLUDED
 #define QMITK_POINTLIST_VIEW_H_INCLUDED
 
 #include "MitkQtWidgetsExtExports.h"
-#include "QmitkPointListModel.h"
+
+#include <QmitkPointListModel.h>
+
 #include <QLabel>
 #include <QListView>
 #include <mitkSliceNavigationController.h>
 
-class QmitkStdMultiWidget;
+class QmitkAbstractMultiWidget;
 
 /*!
 * \brief GUI widget for handling mitk::PointSet
 *
 * Displays all the points in a mitk::PointSet graphically.
 * Reacts automatically to changes in the PointSet's selection status.
 * Updates PointSet's selection status when this list's selection changes.
 *
-* If a QmitkStdMultiWidget is assigned via SetMultiWidget(), the
-* crosshair of the QmitkStdMultiWidget is moved to the currently selected
+* If a QmitkAbstractMultiWidget is assigned via SetMultiWidget(), the
+* crosshair of the QmitkAbstractMultiWidget is moved to the currently selected
 * point.
 *
 */
 class MITKQTWIDGETSEXT_EXPORT QmitkPointListView : public QListView
 {
   Q_OBJECT
 
 public:
   QmitkPointListView(QWidget *parent = nullptr);
   ~QmitkPointListView() override;
 
   /// assign a point set for observation
   void SetPointSetNode(mitk::DataNode *pointSetNode);
 
   /// which point set to work on
   const mitk::PointSet *GetPointSet() const;
 
   /**
   * \brief If Multiwidget is set, the crosshair is automatically centering to the selected point
   * As an alternative, if you dont have a multiwidget, you can call SetSnc1, SetSnc2, SetSnc3 to set the
   * SliceNavigationControllers directly to enable the focussing feature.
   */
-  void SetMultiWidget(QmitkStdMultiWidget *multiWidget);
+  void SetMultiWidget(QmitkAbstractMultiWidget* multiWidget);
 
-  QmitkStdMultiWidget *GetMultiWidget()
-    const; ///< return the QmitkStdMultiWidget that is used for updating render window crosshair
+  /**
+   * \brief Return the QmitkAbstractMultiWidget that is used for updating the render window crosshair.
+   */
+  QmitkAbstractMultiWidget* GetMultiWidget() const;
 
   /**
    * @brief Add a mitk::SliceNavigationController instance.
    * @param snc The mitk::SliceNavigationController instance.
    *
    * This method adds \c snc to the set of slice navigation controllers which are
    * used to navigate to the selected point.
    */
   void AddSliceNavigationController(mitk::SliceNavigationController *snc);
 
   /**
    * @brief Remove a mitk::SliceNavigationController instance.
    * @param snc The mitk::SliceNavigationController instance.
    *
    * This method removes \c snc from the set of slice navigation controllers which are
    * used to navigate to the selected point.
    */
   void RemoveSliceNavigationController(mitk::SliceNavigationController *snc);
 
 signals:
 
   void SignalPointSelectionChanged(); ///< this signal is emmitted, if the selection of a point in the pointset is changed
   void SignalTimeStepChanged(int);
 
 protected slots:
 
   /// Filtering double click event for editing point coordinates via a dialog
   void OnPointDoubleClicked(const QModelIndex &index);
 
   /// called when the point set data structure changes
   void OnPointSetSelectionChanged();
 
   /// called when the selection of the view widget changes
   void OnListViewSelectionChanged(const QItemSelection &selected, const QItemSelection &deselected);
 
   /// open ContextMenu
   void ctxMenu(const QPoint &pos);
 
   /// Turn TimeStep Fading On/Off
   void SetFading(bool onOff);
 
   /// Delete all points in the list
   void ClearPointList();
 
   /// delete all points in the list in the current timestep
   void ClearPointListTS();
 
 protected:
   void keyPressEvent(QKeyEvent *e) override;    ///< react to F2, F3 and DEL keys
   void wheelEvent(QWheelEvent *event) override; ///< change timestep of the current pointset by mouse wheel
 
   std::set<mitk::SliceNavigationController *> m_Sncs;
 
   QmitkPointListModel *m_PointListModel;
   bool m_SelfCall;
   bool m_showFading;
 
   /// used to position the planes on a selected point
-  QmitkStdMultiWidget *m_MultiWidget;
+  QmitkAbstractMultiWidget* m_MultiWidget;
 };
 
 #endif
diff --git a/Modules/QtWidgetsExt/include/QmitkPointListViewWidget.h b/Modules/QtWidgetsExt/include/QmitkPointListViewWidget.h
deleted file mode 100644
index 51420445c1..0000000000
--- a/Modules/QtWidgetsExt/include/QmitkPointListViewWidget.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#ifndef QmitkPointListViewWidget_h
-#define QmitkPointListViewWidget_h
-
-#include "MitkQtWidgetsExtExports.h"
-#include <QListWidget>
-
-#include <mitkPointSet.h>
-#include <mitkWeakPointer.h>
-
-class QmitkStdMultiWidget;
-
-/*!
- * \brief GUI widget for handling mitk::PointSet
- *
- * Displays all the points in a mitk::PointSet graphically.
- * Reacts automatically to changes in the PointSet's selection status.
- * Updates PointSet's selection status when this list's selection changes.
- *
- * If a QmitkStdMultiWidget is assigned via SetMultiWidget(), the
- * crosshair of the QmitkStdMultiWidget is moved to the currently selected
- * point.
- *
- */
-class MITKQTWIDGETSEXT_EXPORT QmitkPointListViewWidget : public QListWidget
-{
-  Q_OBJECT
-
-signals:
-  void PointSelectionChanged(); ///< this signal is emmitted, if the selection of a point in the pointset is changed
-public:
-  QmitkPointListViewWidget(QWidget *parent = nullptr);
-  ~QmitkPointListViewWidget() override;
-
-  /// assign a point set for observation
-  void SetPointSet(mitk::PointSet *pointSet);
-
-  /// which point set to work on
-  const mitk::PointSet *GetPointSet() const;
-
-  void SetMultiWidget(
-    QmitkStdMultiWidget *multiWidget); ///< assign a QmitkStdMultiWidget for updating render window crosshair
-
-  QmitkStdMultiWidget *GetMultiWidget()
-    const; ///< return the QmitkStdMultiWidget that is used for updating render window crosshair
-
-  /// which time step to display/model
-  void SetTimeStep(int t);
-
-  /// which time step to display/model
-  int GetTimeStep() const;
-
-  /// observer for point set "modified" events
-  void OnPointSetChanged();
-
-  /// observer for point set "delete" events
-  void OnPointSetDeleted();
-
-protected slots:
-  ///
-  /// Filtering double click event for editing point coordinates via a dialog
-  ///
-  void OnItemDoubleClicked(QListWidgetItem *item);
-
-  /// called when the selection of the view widget changes
-  void OnCurrentRowChanged(int /*currentRow*/);
-
-protected:
-  void keyPressEvent(QKeyEvent *e) override; ///< react to F2, F3 and DEL keys
-  void MoveSelectedPointUp();
-  void MoveSelectedPointDown();
-  void RemoveSelectedPoint();
-  void Update(bool currentRowChanged = false);
-
-protected:
-  mitk::WeakPointer<mitk::PointSet> m_PointSet;
-
-  unsigned long m_PointSetDeletedTag;
-  unsigned long m_PointSetModifiedTag;
-
-  int m_TimeStep;
-
-  bool m_SelfCall;
-
-  /// used to position the planes on a selected point
-  QmitkStdMultiWidget *m_MultiWidget;
-};
-
-#endif
diff --git a/Modules/QtWidgetsExt/include/QmitkPointListWidget.h b/Modules/QtWidgetsExt/include/QmitkPointListWidget.h
index b886dea24a..20ffd84ce7 100644
--- a/Modules/QtWidgetsExt/include/QmitkPointListWidget.h
+++ b/Modules/QtWidgetsExt/include/QmitkPointListWidget.h
@@ -1,152 +1,154 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #ifndef QmitkPointListWidget_H
 #define QmitkPointListWidget_H
 
 #include "MitkQtWidgetsExtExports.h"
+
 #include <QmitkPointListModel.h>
 #include <QmitkPointListView.h>
 
-#include <QmitkStdMultiWidget.h>
 #include <mitkDataInteractor.h>
 #include <mitkDataNode.h>
 #include <mitkPointSet.h>
 
 #include <QPushButton>
 #include <QToolButton>
 
+class QmitkAbstractMultiWidget;
+
 /*!
  * \brief Widget for regular operations on point sets
  *
  * Displays a list of point coordinates and a couple of
  * buttons which
  *
  * \li enable point set interaction
  * \li clear all points from a set
  * \li load points from file
  * \li save points to file
  *
  * The user/application module of this widget needs to
  * assign a mitk::PointSet object to this widget. The user
  * also has to decide whether it wants to put the point set
  * into (a) DataStorage. This widget will not add/remove
  * point sets to DataStorage.
  *
  * If the render window crosshair should be moved to the
  * currently selected point, the widget user has to provide
- * a QmitkStdMultiWidget object.
+ * a QmitkAbstractMultiWidget object.
  */
 
 class MITKQTWIDGETSEXT_EXPORT QmitkPointListWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   QmitkPointListWidget(QWidget *parent = nullptr, int orientation = 0);
   ~QmitkPointListWidget() override;
 
   void SetupConnections();
 
   /**
    * @brief Add a mitk::SliceNavigationController instance.
    * @param snc The mitk::SliceNavigationController instance.
    *
    * This method adds \c snc to the set of slice navigation controllers which are
    * used to navigate to the selected point.
    */
   void AddSliceNavigationController(mitk::SliceNavigationController *snc);
 
   /**
    * @brief Remove a mitk::SliceNavigationController instance.
    * @param snc The mitk::SliceNavigationController instance.
    *
    * This method removes \c snc from the set of slice navigation controllers which are
    * used to navigate to the selected point.
    */
   void RemoveSliceNavigationController(mitk::SliceNavigationController *snc);
 
   /** @brief assign a point set (contained in a node of DataStorage) for observation */
   void SetPointSet(mitk::PointSet *newPs);
   mitk::PointSet *GetPointSet();
 
   /** @brief assign a point set (contained in a node of DataStorage) for observation */
   void SetPointSetNode(mitk::DataNode *newNode);
   mitk::DataNode *GetPointSetNode();
 
-  /** @brief assign a QmitkStdMultiWidget for updating render window crosshair */
-  void SetMultiWidget(QmitkStdMultiWidget *multiWidget);
+  /** @brief assign a QmitkAbstractMultiWidget for updating render window crosshair */
+  void SetMultiWidget(QmitkAbstractMultiWidget*multiWidget);
 
   /** @brief itk observer for node "delete" events */
   void OnNodeDeleted(const itk::EventObject &e);
 
   /** @brief Unselects the edit button if it is selected. */
   void UnselectEditButton();
 
 public slots:
   void DeactivateInteractor(bool deactivate);
   void EnableEditButton(bool enabled);
 
 signals:
   /** @brief signal to inform about the state of the EditPointSetButton, whether an interactor for setting points is
    * active or not */
   void EditPointSets(bool active);
   /// signal to inform that the selection of a point in the pointset has changed
   void PointSelectionChanged();
   /// signal to inform about cleared or loaded point sets
   void PointListChanged();
 
 protected slots:
   void OnBtnSavePoints();
   void OnBtnLoadPoints();
   void RemoveSelectedPoint();
   void MoveSelectedPointDown();
   void MoveSelectedPointUp();
   void OnBtnAddPoint(bool checked);
   void OnBtnAddPointManually();
   void OnTimeStepChanged(int timeStep);
 
   /*!
   \brief pass through signal from PointListView that point selection has changed
   */
   void OnPointSelectionChanged();
 
   void OnListDoubleClick();
 
 protected:
   void SetupUi();
   void ObserveNewNode(mitk::DataNode *node);
 
   QmitkPointListView *m_PointListView;
 
   mitk::DataNode::Pointer m_PointSetNode;
 
   int m_Orientation;
 
   QPushButton *m_MovePointUpBtn;
   QPushButton *m_MovePointDownBtn;
   QPushButton *m_RemovePointBtn;
   QPushButton *m_SavePointsBtn;
   QPushButton *m_LoadPointsBtn;
   QPushButton *m_ToggleAddPoint;
   QPushButton *m_AddPoint;
   QLabel *m_TimeStepDisplay;
   QLabel *m_TimeStepLabel;
 
   mitk::DataInteractor::Pointer m_DataInteractor;
   int m_TimeStep;
   bool m_EditAllowed;
   unsigned long m_NodeObserverTag;
 
   QmitkPointListModel *m_PointListModel;
 };
 
 #endif
diff --git a/Modules/QtWidgetsExt/src/QmitkPointListView.cpp b/Modules/QtWidgetsExt/src/QmitkPointListView.cpp
index 9ecf11704a..cf25972d78 100644
--- a/Modules/QtWidgetsExt/src/QmitkPointListView.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkPointListView.cpp
@@ -1,335 +1,336 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkPointListView.h"
 
-#include "QmitkEditPointDialog.h"
-#include "QmitkPointListModel.h"
-#include "QmitkRenderWindow.h"
-#include "QmitkStdMultiWidget.h"
+#include <QmitkEditPointDialog.h>
+#include <QmitkPointListModel.h>
+#include <QmitkRenderWindow.h>
+#include <QmitkAbstractMultiWidget.h>
 
-#include "mitkRenderingManager.h"
+#include <mitkRenderingManager.h>
 
 #include <QKeyEvent>
 #include <QMenu>
 #include <QMessageBox>
 #include <QPalette>
 #include <QTimer>
 
 QmitkPointListView::QmitkPointListView(QWidget *parent)
   : QListView(parent),
     m_PointListModel(new QmitkPointListModel()),
     m_SelfCall(false),
     m_showFading(false),
     m_MultiWidget(nullptr)
 {
   QListView::setAlternatingRowColors(true);
 
   QListView::setSelectionBehavior(QAbstractItemView::SelectItems);
   QListView::setSelectionMode(QAbstractItemView::SingleSelection);
   QListView::setModel(m_PointListModel);
   QString tooltip = QString("Use the F2/F3 keys to move a point up/down, the Del key to remove a point\nand the mouse "
                             "wheel to change the timestep.\n\nTimeStep:\t%1")
                       .arg(0);
   QListView::setToolTip(tooltip);
   this->setContextMenuPolicy(Qt::CustomContextMenu);
 
   this->setMinimumHeight(40);
 
   this->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
 
   connect(m_PointListModel, SIGNAL(SignalUpdateSelection()), this, SLOT(OnPointSetSelectionChanged()));
 
   connect(this, SIGNAL(doubleClicked(const QModelIndex &)), this, SLOT(OnPointDoubleClicked(const QModelIndex &)));
 
   connect(QListView::selectionModel(),
           SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
           this,
           SLOT(OnListViewSelectionChanged(const QItemSelection &, const QItemSelection &)));
 
   // T28213: Every single action in the context menu is either not implemented or working. Implement/fix or remove in future.
   // connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(ctxMenu(const QPoint &)));
 }
 
 QmitkPointListView::~QmitkPointListView()
 {
   delete m_PointListModel;
 }
 
 void QmitkPointListView::SetPointSetNode(mitk::DataNode *pointSetNode)
 {
   m_PointListModel->SetPointSetNode(pointSetNode);
 }
 
 const mitk::PointSet *QmitkPointListView::GetPointSet() const
 {
   return m_PointListModel->GetPointSet();
 }
 
-void QmitkPointListView::SetMultiWidget(QmitkStdMultiWidget *multiWidget)
+void QmitkPointListView::SetMultiWidget(QmitkAbstractMultiWidget* multiWidget)
 {
   m_MultiWidget = multiWidget;
   if (nullptr != m_MultiWidget)
   {
-    AddSliceNavigationController(m_MultiWidget->GetRenderWindow1()->GetSliceNavigationController());
-    AddSliceNavigationController(m_MultiWidget->GetRenderWindow2()->GetSliceNavigationController());
-    AddSliceNavigationController(m_MultiWidget->GetRenderWindow3()->GetSliceNavigationController());
+    for (const auto& renderWindow : m_MultiWidget->GetRenderWindows().values())
+    {
+      AddSliceNavigationController(renderWindow->GetSliceNavigationController());
+    }
   }
 }
 
-QmitkStdMultiWidget *QmitkPointListView::GetMultiWidget() const
+QmitkAbstractMultiWidget* QmitkPointListView::GetMultiWidget() const
 {
   return m_MultiWidget;
 }
 
 void QmitkPointListView::OnPointDoubleClicked(const QModelIndex &index)
 {
   mitk::PointSet::PointType p;
   mitk::PointSet::PointIdentifier id;
   m_PointListModel->GetPointForModelIndex(index, p, id);
   QmitkEditPointDialog _EditPointDialog(this);
   _EditPointDialog.SetPoint(m_PointListModel->GetPointSet(), id, m_PointListModel->GetTimeStep());
   _EditPointDialog.exec();
 }
 
 void QmitkPointListView::OnPointSetSelectionChanged()
 {
   const mitk::PointSet *pointSet = m_PointListModel->GetPointSet();
   if (pointSet == nullptr)
     return;
 
   // update this view's selection status as a result to changes in the point set data structure
   m_SelfCall = true;
   int timeStep = m_PointListModel->GetTimeStep();
 
   if (pointSet->GetNumberOfSelected(timeStep) > 1)
   {
     MITK_ERROR << "Point set has multiple selected points. This view is not designed for more than one selected point.";
   }
 
   int selectedIndex = pointSet->SearchSelectedPoint(timeStep);
 
   if (selectedIndex == -1) // no selected point is found
   {
     m_SelfCall = false;
     return;
   }
 
   QModelIndex index;
 
   bool modelIndexOkay = m_PointListModel->GetModelIndexForPointID(selectedIndex, index);
 
   if (modelIndexOkay == true)
     QListView::selectionModel()->select(index, QItemSelectionModel::ClearAndSelect);
 
   emit SignalPointSelectionChanged();
 
   m_SelfCall = false;
 }
 
 void QmitkPointListView::OnListViewSelectionChanged(const QItemSelection &selected,
                                                     const QItemSelection & /*deselected*/)
 {
   if (m_SelfCall)
     return;
 
   mitk::PointSet *pointSet = const_cast<mitk::PointSet *>(m_PointListModel->GetPointSet());
 
   if (pointSet == nullptr)
     return;
 
   // (take care that this widget doesn't react to self-induced changes by setting m_SelfCall)
   m_SelfCall = true;
 
   // update selection of all points in pointset: select the one(s) that are selected in the view, deselect all others
   QModelIndexList selectedIndexes = selected.indexes();
 
   // only call setSelectInfo on a point set with 'selected = true' if you deselcted the other entries
   int indexToSelect = -1;
 
   for (mitk::PointSet::PointsContainer::Iterator it =
          pointSet->GetPointSet(m_PointListModel->GetTimeStep())->GetPoints()->Begin();
        it != pointSet->GetPointSet(m_PointListModel->GetTimeStep())->GetPoints()->End();
        ++it)
   {
     QModelIndex index;
     if (m_PointListModel->GetModelIndexForPointID(it->Index(), index))
     {
       if (selectedIndexes.indexOf(index) != -1) // index is found in the selected indices list
       {
 		indexToSelect = it->Index();
       }
       else
       {
         pointSet->SetSelectInfo(it->Index(), false, m_PointListModel->GetTimeStep());
       }
     }
   }
 
   // force selection of only one index after deselecting the others
   if (indexToSelect > -1) {
 	  pointSet->SetSelectInfo(indexToSelect, true, m_PointListModel->GetTimeStep());
 
 	  mitk::Point3D p = pointSet->GetPoint(indexToSelect, m_PointListModel->GetTimeStep());
 
 	  for (auto snc : m_Sncs)
 		  snc->SelectSliceByPoint(p);
   }
 
   m_SelfCall = false;
 
   emit SignalPointSelectionChanged();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPointListView::keyPressEvent(QKeyEvent *e)
 {
   if (m_PointListModel == nullptr)
     return;
 
   int key = e->key();
 
   switch (key)
   {
     case Qt::Key_F2:
       m_PointListModel->MoveSelectedPointUp();
       break;
     case Qt::Key_F3:
       m_PointListModel->MoveSelectedPointDown();
       break;
     case Qt::Key_Delete:
       m_PointListModel->RemoveSelectedPoint();
       break;
     default:
       break;
   }
 }
 
 void QmitkPointListView::wheelEvent(QWheelEvent *event)
 {
   if (!m_PointListModel || !m_PointListModel->GetPointSet() ||
       (int)(m_PointListModel->GetPointSet()->GetTimeSteps()) == 1)
     return;
 
   int whe = event->delta();
   mitk::PointSet::Pointer ps = dynamic_cast<mitk::PointSet *>(m_PointListModel->GetPointSet());
   unsigned int numberOfTS = ps->GetTimeSteps();
 
   if (numberOfTS == 1)
     return;
   int currentTS = this->m_PointListModel->GetTimeStep();
   if (whe > 0)
   {
     if ((currentTS + 1 >= (int)numberOfTS))
       return;
 
     this->m_PointListModel->SetTimeStep(++currentTS);
   }
   else
   {
     if ((currentTS <= 0))
       return;
     this->m_PointListModel->SetTimeStep(--currentTS);
   }
 
   QString tooltip = QString("Use the F2/F3 keys to move a point up/down, the Del key to remove a point\nand the mouse "
                             "wheel to change the timestep.\n\nTimeStep:\t%1")
                       .arg(currentTS);
   this->setToolTip(tooltip);
 
   emit SignalTimeStepChanged(currentTS);
 }
 
 void QmitkPointListView::ctxMenu(const QPoint &pos)
 {
   QMenu *menu = new QMenu;
 
   // add Fading check
   QAction *showFading = new QAction(this);
   showFading->setCheckable(false); // TODO: reset when fading is working
   showFading->setEnabled(false);   // TODO: reset when fading is working
   showFading->setText("Fade TimeStep");
   connect(showFading, SIGNAL(triggered(bool)), this, SLOT(SetFading(bool)));
   menu->addAction(showFading);
 
   // add Clear action
   QAction *clearList = new QAction(this);
   clearList->setText("Clear List");
   connect(clearList, SIGNAL(triggered()), this, SLOT(ClearPointList()));
   menu->addAction(clearList);
 
   // add Clear TimeStep action
   QAction *clearTS = new QAction(this);
   clearTS->setText("Clear current time step");
   connect(clearTS, SIGNAL(triggered()), this, SLOT(ClearPointListTS()));
   menu->addAction(clearTS);
 
   menu->exec(this->mapToGlobal(pos));
 }
 
 void QmitkPointListView::SetFading(bool onOff)
 {
   m_showFading = onOff;
 }
 
 void QmitkPointListView::ClearPointList()
 {
   if (!m_PointListModel->GetPointSet())
     return;
   mitk::PointSet::Pointer curPS = m_PointListModel->GetPointSet();
   if (curPS->GetSize() == 0)
     return;
 
   switch (QMessageBox::question(this,
                                 tr("Clear Points"),
                                 tr("Remove all points from the displayed list?"),
                                 QMessageBox::Yes | QMessageBox::No,
                                 QMessageBox::No))
   {
     case QMessageBox::Yes:
     {
       mitk::PointSet::PointsIterator it;
       mitk::PointSet::PointsContainer *curPsPoints;
       while (!curPS->IsEmptyTimeStep(0))
       {
         curPsPoints = curPS->GetPointSet()->GetPoints();
         it = curPsPoints->Begin();
         curPS->SetSelectInfo(it->Index(), true);
         m_PointListModel->RemoveSelectedPoint();
       }
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       break;
     }
     case QMessageBox::No:
     default:
       break;
   }
 }
 
 void QmitkPointListView::ClearPointListTS()
 {
 }
 
 void QmitkPointListView::AddSliceNavigationController(mitk::SliceNavigationController *snc)
 {
   if (snc == nullptr)
     return;
   m_Sncs.insert(snc);
 }
 
 void QmitkPointListView::RemoveSliceNavigationController(mitk::SliceNavigationController *snc)
 {
   if (snc == nullptr)
     return;
   m_Sncs.erase(snc);
 }
diff --git a/Modules/QtWidgetsExt/src/QmitkPointListViewWidget.cpp b/Modules/QtWidgetsExt/src/QmitkPointListViewWidget.cpp
deleted file mode 100644
index 347368f308..0000000000
--- a/Modules/QtWidgetsExt/src/QmitkPointListViewWidget.cpp
+++ /dev/null
@@ -1,256 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include "QmitkPointListViewWidget.h"
-
-#include "QmitkEditPointDialog.h"
-#include "QmitkPointListModel.h"
-#include "QmitkStdMultiWidget.h"
-
-#include "mitkInteractionConst.h"
-#include "mitkPointOperation.h"
-#include "mitkRenderingManager.h"
-
-#include <QKeyEvent>
-
-QmitkPointListViewWidget::QmitkPointListViewWidget(QWidget *parent)
-  : QListWidget(parent), m_TimeStep(0), m_SelfCall(false), m_MultiWidget(nullptr)
-{
-  QListWidget::setAlternatingRowColors(true);
-  // logic
-
-  QListWidget::setSelectionBehavior(QAbstractItemView::SelectRows);
-  QListWidget::setSelectionMode(QAbstractItemView::SingleSelection);
-
-  connect(this, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(OnItemDoubleClicked(QListWidgetItem *)));
-
-  connect(this, SIGNAL(currentRowChanged(int)), this, SLOT(OnCurrentRowChanged(int)));
-}
-
-QmitkPointListViewWidget::~QmitkPointListViewWidget()
-{
-  this->SetPointSet(nullptr); // remove listener
-}
-
-void QmitkPointListViewWidget::SetPointSet(mitk::PointSet *pointSet)
-{
-  if (!m_PointSet.IsExpired())
-  {
-    auto pointSet = m_PointSet.Lock();
-
-    pointSet->RemoveObserver(m_PointSetModifiedTag);
-    pointSet->RemoveObserver(m_PointSetDeletedTag);
-  }
-
-  m_PointSet = pointSet;
-
-  if (!m_PointSet.IsExpired())
-  {
-    auto pointSet = m_PointSet.Lock();
-
-    auto onPointSetDeleted = itk::SimpleMemberCommand<QmitkPointListViewWidget>::New();
-    onPointSetDeleted->SetCallbackFunction(this, &QmitkPointListViewWidget::OnPointSetDeleted);
-    m_PointSetDeletedTag = pointSet->AddObserver(itk::DeleteEvent(), onPointSetDeleted);
-
-    auto onPointSetModified = itk::SimpleMemberCommand<QmitkPointListViewWidget>::New();
-    onPointSetModified->SetCallbackFunction(this, &QmitkPointListViewWidget::OnPointSetChanged);
-    m_PointSetModifiedTag = pointSet->AddObserver(itk::DeleteEvent(), onPointSetModified);
-  }
-
-  this->Update();
-}
-
-const mitk::PointSet *QmitkPointListViewWidget::GetPointSet() const
-{
-  return m_PointSet.Lock();
-}
-
-void QmitkPointListViewWidget::SetTimeStep(int t)
-{
-  m_TimeStep = t;
-  this->Update();
-}
-
-int QmitkPointListViewWidget::GetTimeStep() const
-{
-  return m_TimeStep;
-}
-
-void QmitkPointListViewWidget::SetMultiWidget(QmitkStdMultiWidget *multiWidget)
-{
-  m_MultiWidget = multiWidget;
-}
-
-QmitkStdMultiWidget *QmitkPointListViewWidget::GetMultiWidget() const
-{
-  return m_MultiWidget;
-}
-
-void QmitkPointListViewWidget::OnPointSetChanged()
-{
-  if (!m_SelfCall)
-    this->Update();
-}
-
-void QmitkPointListViewWidget::OnPointSetDeleted()
-{
-  this->SetPointSet(nullptr);
-  this->Update();
-}
-
-void QmitkPointListViewWidget::OnItemDoubleClicked(QListWidgetItem *item)
-{
-  QmitkEditPointDialog _EditPointDialog(this);
-  _EditPointDialog.SetPoint(m_PointSet.Lock(), this->row(item), m_TimeStep);
-  _EditPointDialog.exec();
-}
-
-void QmitkPointListViewWidget::OnCurrentRowChanged(int)
-{
-  this->Update(true);
-}
-
-void QmitkPointListViewWidget::keyPressEvent(QKeyEvent *e)
-{
-  if (m_PointSet.IsExpired())
-    return;
-
-  int key = e->key();
-  switch (key)
-  {
-    case Qt::Key_F2:
-      this->MoveSelectedPointUp();
-      break;
-    case Qt::Key_F3:
-      this->MoveSelectedPointDown();
-      break;
-    case Qt::Key_Delete:
-      this->RemoveSelectedPoint();
-      break;
-    default:
-      break;
-  }
-}
-
-void QmitkPointListViewWidget::MoveSelectedPointUp()
-{
-  if (m_PointSet.IsExpired())
-    return;
-
-  auto pointSet = m_PointSet.Lock();
-
-  mitk::PointSet::PointIdentifier selectedID;
-  selectedID = pointSet->SearchSelectedPoint(m_TimeStep);
-  mitk::PointOperation *doOp =
-    new mitk::PointOperation(mitk::OpMOVEPOINTUP, pointSet->GetPoint(selectedID, m_TimeStep), selectedID, true);
-  pointSet->ExecuteOperation(doOp);
-  mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in Pointset/Mapper
-}
-
-void QmitkPointListViewWidget::MoveSelectedPointDown()
-{
-  if (m_PointSet.IsExpired())
-    return;
-
-  auto pointSet = m_PointSet.Lock();
-
-  mitk::PointSet::PointIdentifier selectedID;
-  selectedID = pointSet->SearchSelectedPoint(m_TimeStep);
-  mitk::PointOperation *doOp =
-    new mitk::PointOperation(mitk::OpMOVEPOINTDOWN, pointSet->GetPoint(selectedID, m_TimeStep), selectedID, true);
-  pointSet->ExecuteOperation(doOp);
-  mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in Pointset/Mapper
-}
-
-void QmitkPointListViewWidget::RemoveSelectedPoint()
-{
-  if (m_PointSet.IsExpired())
-    return;
-
-  auto pointSet = m_PointSet.Lock();
-
-  mitk::PointSet::PointIdentifier selectedID;
-  selectedID = pointSet->SearchSelectedPoint(m_TimeStep);
-  mitk::PointOperation *doOp =
-    new mitk::PointOperation(mitk::OpREMOVE, pointSet->GetPoint(selectedID, m_TimeStep), selectedID, true);
-  pointSet->ExecuteOperation(doOp);
-  mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in Pointset/Mapper
-}
-
-void QmitkPointListViewWidget::Update(bool currentRowChanged)
-{
-  if (m_SelfCall)
-    return;
-
-  if (m_PointSet.IsExpired())
-  {
-    this->clear();
-    return;
-  }
-
-  auto pointSet = m_PointSet.Lock();
-
-  m_SelfCall = true;
-  QString text;
-  int i = 0;
-
-  mitk::PointSet::DataType::Pointer pointset = pointSet->GetPointSet(m_TimeStep);
-  for (mitk::PointSet::PointsContainer::Iterator it = pointset->GetPoints()->Begin();
-       it != pointset->GetPoints()->End();
-       ++it)
-  {
-    text = QString("%0: (%1, %2, %3)")
-             .arg(i, 3)
-             .arg(it.Value().GetElement(0), 0, 'f', 3)
-             .arg(it.Value().GetElement(1), 0, 'f', 3)
-             .arg(it.Value().GetElement(2), 0, 'f', 3);
-
-    if (i == this->count())
-      this->addItem(text); // insert text
-    else
-      this->item(i)->setText(text); // update text
-
-    if (currentRowChanged)
-    {
-      if (i == this->currentRow())
-        pointSet->SetSelectInfo(this->currentRow(), true, m_TimeStep);
-      else
-        pointSet->SetSelectInfo(it->Index(), false, m_TimeStep); // select nothing now
-    }
-    ++i;
-  }
-
-  // remove unnecessary listwidgetitems
-  while (pointSet->GetPointSet(m_TimeStep)->GetPoints()->Size() < (unsigned int)this->count())
-  {
-    QListWidgetItem *item = this->takeItem(this->count() - 1);
-    delete item;
-  }
-
-  // update selection in pointset or in the list widget
-  if (!currentRowChanged)
-  {
-    if (pointSet->GetNumberOfSelected(m_TimeStep) > 1)
-    {
-      /// @TODO use logging as soon as available
-      std::cerr << "Point set has multiple selected points. This view is not designed for more than one selected point."
-                << std::endl;
-    }
-
-    int selectedIndex = pointSet->SearchSelectedPoint(m_TimeStep);
-    if (selectedIndex != -1) // no selected point is found
-    {
-      this->setCurrentRow(selectedIndex);
-    }
-  }
-  m_SelfCall = false;
-}
diff --git a/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp b/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp
index b2c9dcd2a8..04c09b9610 100644
--- a/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp
@@ -1,484 +1,481 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
+
 #include "QmitkPointListWidget.h"
-#include "QmitkPointListView.h"
-#include "QmitkPointListModel.h"
 
 #include <QDir>
 #include <QFileDialog>
 #include <QHBoxLayout>
 #include <QMessageBox>
 #include <mitkIOUtil.h>
 
-
+#include <QmitkAbstractMultiWidget.h>
 #include <QmitkEditPointDialog.h>
 #include <QmitkStyleManager.h>
 
 #include <mitkPointSetDataInteractor.h>
 
-#include <mitkDataInteractor.h>
-
 QmitkPointListWidget::QmitkPointListWidget(QWidget *parent, int orientation)
   : QWidget(parent),
     m_PointListView(nullptr),
     m_PointSetNode(nullptr),
     m_Orientation(0),
     m_MovePointUpBtn(nullptr),
     m_MovePointDownBtn(nullptr),
     m_RemovePointBtn(nullptr),
     m_SavePointsBtn(nullptr),
     m_LoadPointsBtn(nullptr),
     m_ToggleAddPoint(nullptr),
     m_AddPoint(nullptr),
     m_TimeStepDisplay(nullptr),
     m_DataInteractor(nullptr),
     m_TimeStep(0),
     m_EditAllowed(true),
     m_NodeObserverTag(0)
 {
   m_PointListView = new QmitkPointListView();
 
   if (orientation != 0)
     m_Orientation = orientation;
 
   SetupUi();
   SetupConnections();
   ObserveNewNode(nullptr);
 }
 
 QmitkPointListWidget::~QmitkPointListWidget()
 {
   m_DataInteractor = nullptr;
 
   if (m_PointSetNode && m_NodeObserverTag)
   {
     m_PointSetNode->RemoveObserver(m_NodeObserverTag);
     m_NodeObserverTag = 0;
   }
 
   delete m_PointListView;
 }
 
 void QmitkPointListWidget::SetupConnections()
 {
   connect(this->m_LoadPointsBtn, SIGNAL(clicked()), this, SLOT(OnBtnLoadPoints()));
   connect(this->m_SavePointsBtn, SIGNAL(clicked()), this, SLOT(OnBtnSavePoints()));
   connect(this->m_MovePointUpBtn, SIGNAL(clicked()), this, SLOT(MoveSelectedPointUp()));
   connect(this->m_MovePointDownBtn, SIGNAL(clicked()), this, SLOT(MoveSelectedPointDown()));
   connect(this->m_RemovePointBtn, SIGNAL(clicked()), this, SLOT(RemoveSelectedPoint()));
   connect(this->m_ToggleAddPoint, SIGNAL(toggled(bool)), this, SLOT(OnBtnAddPoint(bool)));
   connect(this->m_AddPoint, SIGNAL(clicked()), this, SLOT(OnBtnAddPointManually()));
   connect(this->m_PointListView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(OnListDoubleClick()));
   connect(this->m_PointListView, SIGNAL(SignalPointSelectionChanged()), this, SLOT(OnPointSelectionChanged()));
   connect(this->m_PointListView, SIGNAL(SignalTimeStepChanged(int)), this, SLOT(OnTimeStepChanged(int)));
 }
 
 void QmitkPointListWidget::OnTimeStepChanged(int timeStep)
 {
   m_TimeStepLabel->setText(QString("%1").arg(timeStep));
 }
 
 void QmitkPointListWidget::SetupUi()
 {
   // Setup the buttons
 
   m_ToggleAddPoint = new QPushButton();
   m_ToggleAddPoint->setMaximumSize(25, 25);
   m_ToggleAddPoint->setCheckable(true);
   m_ToggleAddPoint->setToolTip("Toggle point editing (use SHIFT  + Left Mouse Button to add Points)");
   m_ToggleAddPoint->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/QtWidgetsExt/plus.svg")));
 
   m_AddPoint = new QPushButton();
   m_AddPoint->setMaximumSize(25, 25);
   m_AddPoint->setToolTip("Manually add point");
   m_AddPoint->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/QtWidgetsExt/plus-xyz.svg")));
 
   m_RemovePointBtn = new QPushButton();
   m_RemovePointBtn->setMaximumSize(25, 25);
   m_RemovePointBtn->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/QtWidgetsExt/eraser.svg")));
   m_RemovePointBtn->setToolTip("Erase one point from list   (Hotkey: DEL)");
 
   m_MovePointUpBtn = new QPushButton();
   m_MovePointUpBtn->setMaximumSize(25, 25);
   m_MovePointUpBtn->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/QtWidgetsExt/arrow-up.svg")));
   m_MovePointUpBtn->setToolTip("Swap selected point upwards   (Hotkey: F2)");
 
   m_MovePointDownBtn = new QPushButton();
   m_MovePointDownBtn->setMaximumSize(25, 25);
   m_MovePointDownBtn->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/QtWidgetsExt/arrow-down.svg")));
   m_MovePointDownBtn->setToolTip("Swap selected point downwards   (Hotkey: F3)");
 
   m_SavePointsBtn = new QPushButton();
   m_SavePointsBtn->setMaximumSize(25, 25);
   m_SavePointsBtn->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/QtWidgetsExt/save.svg")));
   m_SavePointsBtn->setToolTip("Save points to file");
 
   m_LoadPointsBtn = new QPushButton();
   m_LoadPointsBtn->setMaximumSize(25, 25);
   m_LoadPointsBtn->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/QtWidgetsExt/folder-open.svg")));
   m_LoadPointsBtn->setToolTip("Load list of points from file (REPLACES current content)");
 
   int i;
 
   QBoxLayout *lay1;
   QBoxLayout *lay2;
   QBoxLayout *lay3;
 
   switch (m_Orientation)
   {
     case 0:
       lay1 = new QVBoxLayout(this);
       lay2 = new QHBoxLayout();
       i = 0;
       break;
 
     case 1:
       lay1 = new QHBoxLayout(this);
       lay2 = new QVBoxLayout();
       i = -1;
       break;
 
     case 2:
       lay1 = new QHBoxLayout(this);
       lay2 = new QVBoxLayout();
       i = 0;
       break;
 
     default:
       lay1 = new QVBoxLayout(this);
       lay2 = new QHBoxLayout();
       i = -1;
       break;
   }
 
   // setup Layouts
 
   this->setLayout(lay1);
   lay2->stretch(true);
   lay2->addWidget(m_ToggleAddPoint);
   lay2->addWidget(m_AddPoint);
   lay2->addWidget(m_RemovePointBtn);
   lay2->addWidget(m_MovePointUpBtn);
   lay2->addWidget(m_MovePointDownBtn);
   lay2->addWidget(m_SavePointsBtn);
   lay2->addWidget(m_LoadPointsBtn);
 
   // setup Labels
   m_TimeStepDisplay = new QLabel;
   m_TimeStepLabel = new QLabel;
   lay3 = new QHBoxLayout;
 
   m_TimeStepDisplay->setMaximumSize(200, 15);
 
   lay3->stretch(true);
   lay3->setAlignment(Qt::AlignLeft);
   lay3->addWidget(m_TimeStepDisplay);
   lay3->addWidget(m_TimeStepLabel);
 
   m_TimeStepDisplay->setText("Time Step: ");
   m_TimeStepLabel->setMaximumSize(10, 15);
 
   this->OnTimeStepChanged(0);
 
   //Add Layouts
 
   lay1->insertWidget(i, m_PointListView);
   this->setLayout(lay1);
   lay1->addLayout(lay2);
   lay1->addLayout(lay3);
 }
 
 void QmitkPointListWidget::SetPointSet(mitk::PointSet *newPs)
 {
   if (newPs == nullptr)
     return;
 
   this->m_PointSetNode->SetData(newPs);
   dynamic_cast<QmitkPointListModel *>(this->m_PointListView->model())->SetPointSetNode(m_PointSetNode);
   ObserveNewNode(m_PointSetNode);
 }
 
 void QmitkPointListWidget::SetPointSetNode(mitk::DataNode *newNode)
 {
   if (m_DataInteractor.IsNotNull())
     m_DataInteractor->SetDataNode(newNode);
 
   ObserveNewNode(newNode);
   dynamic_cast<QmitkPointListModel *>(this->m_PointListView->model())->SetPointSetNode(newNode);
 }
 
 void QmitkPointListWidget::OnBtnSavePoints()
 {
   if ((dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData())) == nullptr)
     return; // don't write empty point sets. If application logic requires something else then do something else.
   if ((dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData()))->GetSize() == 0)
     return;
 
   // take the previously defined name of node as proposal for filename
   std::string nodeName = m_PointSetNode->GetName();
   nodeName = "/" + nodeName + ".mps";
   QString fileNameProposal = QString();
   fileNameProposal.append(nodeName.c_str());
 
   QString aFilename = QFileDialog::getSaveFileName(
     nullptr, "Save point set", QDir::currentPath() + fileNameProposal, "MITK Pointset (*.mps)");
   if (aFilename.isEmpty())
     return;
 
   try
   {
     mitk::IOUtil::Save(m_PointSetNode->GetData(), aFilename.toStdString());
   }
   catch (...)
   {
     QMessageBox::warning(this,
                          "Save point set",
                          QString("File writer reported problems writing %1\n\n"
                                  "PLEASE CHECK output file!")
                            .arg(aFilename));
   }
 }
 
 void QmitkPointListWidget::OnBtnLoadPoints()
 {
   // get the name of the file to load
   QString filename = QFileDialog::getOpenFileName(nullptr, "Open MITK Pointset", "", "MITK Point Sets (*.mps)");
   if (filename.isEmpty())
     return;
 
   // attempt to load file
   try
   {
     mitk::PointSet::Pointer pointSet = mitk::IOUtil::Load<mitk::PointSet>(filename.toStdString());
     if (pointSet.IsNull())
     {
       QMessageBox::warning(this, "Load point set", QString("File reader could not read %1").arg(filename));
       return;
     }
 
     // loading successful
 
     this->SetPointSet(pointSet);
   }
   catch (...)
   {
     QMessageBox::warning(this, "Load point set", QString("File reader collapsed while reading %1").arg(filename));
   }
   emit PointListChanged();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 mitk::PointSet *QmitkPointListWidget::GetPointSet()
 {
   return dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
 }
 
 mitk::DataNode *QmitkPointListWidget::GetPointSetNode()
 {
   return m_PointSetNode;
 }
 
-void QmitkPointListWidget::SetMultiWidget(QmitkStdMultiWidget *multiWidget)
+void QmitkPointListWidget::SetMultiWidget(QmitkAbstractMultiWidget* multiWidget)
 {
   m_PointListView->SetMultiWidget(multiWidget);
 }
 
 void QmitkPointListWidget::RemoveSelectedPoint()
 {
   if (!m_PointSetNode)
     return;
   mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
   if (!pointSet)
     return;
   if (pointSet->GetSize() == 0)
     return;
 
   QmitkPointListModel *pointListModel = dynamic_cast<QmitkPointListModel *>(m_PointListView->model());
   pointListModel->RemoveSelectedPoint();
   emit PointListChanged();
 }
 
 void QmitkPointListWidget::MoveSelectedPointDown()
 {
   if (!m_PointSetNode)
     return;
   mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
   if (!pointSet)
     return;
   if (pointSet->GetSize() == 0)
     return;
 
   QmitkPointListModel *pointListModel = dynamic_cast<QmitkPointListModel *>(m_PointListView->model());
   pointListModel->MoveSelectedPointDown();
   emit PointListChanged();
 }
 
 void QmitkPointListWidget::MoveSelectedPointUp()
 {
   if (!m_PointSetNode)
     return;
   mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
   if (!pointSet)
     return;
   if (pointSet->GetSize() == 0)
     return;
 
   QmitkPointListModel *pointListModel = dynamic_cast<QmitkPointListModel *>(m_PointListView->model());
   pointListModel->MoveSelectedPointUp();
   emit PointListChanged();
 }
 
 void QmitkPointListWidget::OnBtnAddPoint(bool checked)
 {
   if (m_PointSetNode.IsNotNull())
   {
     if (checked)
     {
       m_DataInteractor = m_PointSetNode->GetDataInteractor();
       // If no data Interactor is present create a new one
       if (m_DataInteractor.IsNull())
       {
         // Create PointSetData Interactor
         m_DataInteractor = mitk::PointSetDataInteractor::New();
         // Load the according state machine for regular point set interaction
         m_DataInteractor->LoadStateMachine("PointSet.xml");
         // Set the configuration file that defines the triggers for the transitions
         m_DataInteractor->SetEventConfig("PointSetConfig.xml");
         // set the DataNode (which already is added to the DataStorage
         m_DataInteractor->SetDataNode(m_PointSetNode);
       }
     }
     else
     {
       m_PointSetNode->SetDataInteractor(nullptr);
       m_DataInteractor = nullptr;
     }
     emit EditPointSets(checked);
   }
 }
 
 void QmitkPointListWidget::OnBtnAddPointManually()
 {
   mitk::PointSet *pointSet = this->GetPointSet();
   QmitkEditPointDialog editPointDialog(this);
 
   if (this->GetPointSet()->IsEmpty())
   {
       editPointDialog.SetPoint(pointSet, 0, m_TimeStep);
   }
 
   else
   {
       mitk::PointSet::PointsIterator maxIt = pointSet->GetMaxId();
       mitk::PointSet::PointIdentifier maxId = maxIt->Index();
       editPointDialog.SetPoint(pointSet, maxId + 1, m_TimeStep);
   }
 
   editPointDialog.exec();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPointListWidget::OnListDoubleClick()
 {
 }
 
 void QmitkPointListWidget::OnPointSelectionChanged()
 {
   emit this->PointSelectionChanged();
 }
 
 void QmitkPointListWidget::DeactivateInteractor(bool)
 {
 }
 
 void QmitkPointListWidget::EnableEditButton(bool enabled)
 {
   m_EditAllowed = enabled;
   if (enabled == false)
     m_ToggleAddPoint->setEnabled(false);
   else
     m_ToggleAddPoint->setEnabled(true);
   OnBtnAddPoint(enabled);
 }
 
 void QmitkPointListWidget::ObserveNewNode(mitk::DataNode *node)
 {
   if (m_DataInteractor.IsNotNull())
     m_DataInteractor->SetDataNode(node);
 
   // remove old observer
   if (m_PointSetNode)
   {
     if (m_DataInteractor)
     {
       m_DataInteractor = nullptr;
       m_ToggleAddPoint->setChecked(false);
     }
 
     m_PointSetNode->RemoveObserver(m_NodeObserverTag);
     m_NodeObserverTag = 0;
   }
 
   m_PointSetNode = node;
   // add new observer if necessary
   if (m_PointSetNode)
   {
     itk::ReceptorMemberCommand<QmitkPointListWidget>::Pointer command =
       itk::ReceptorMemberCommand<QmitkPointListWidget>::New();
     command->SetCallbackFunction(this, &QmitkPointListWidget::OnNodeDeleted);
     m_NodeObserverTag = m_PointSetNode->AddObserver(itk::DeleteEvent(), command);
   }
   else
   {
     m_NodeObserverTag = 0;
   }
 
   if (m_EditAllowed == true)
     m_ToggleAddPoint->setEnabled(m_PointSetNode);
   else
     m_ToggleAddPoint->setEnabled(false);
 
   m_RemovePointBtn->setEnabled(m_PointSetNode);
   m_LoadPointsBtn->setEnabled(m_PointSetNode);
   m_SavePointsBtn->setEnabled(m_PointSetNode);
   m_AddPoint->setEnabled(m_PointSetNode);
 }
 
 void QmitkPointListWidget::OnNodeDeleted(const itk::EventObject &)
 {
   if (m_PointSetNode.IsNotNull() && !m_NodeObserverTag)
     m_PointSetNode->RemoveObserver(m_NodeObserverTag);
   m_NodeObserverTag = 0;
   m_PointSetNode = nullptr;
   m_PointListView->SetPointSetNode(nullptr);
   m_ToggleAddPoint->setEnabled(false);
 
   m_RemovePointBtn->setEnabled(false);
   m_LoadPointsBtn->setEnabled(false);
   m_SavePointsBtn->setEnabled(false);
   m_AddPoint->setEnabled(false);
 }
 
 void QmitkPointListWidget::AddSliceNavigationController(mitk::SliceNavigationController *snc)
 {
   m_PointListView->AddSliceNavigationController(snc);
 }
 
 void QmitkPointListWidget::RemoveSliceNavigationController(mitk::SliceNavigationController *snc)
 {
   m_PointListView->RemoveSliceNavigationController(snc);
 }
 
 void QmitkPointListWidget::UnselectEditButton()
 {
   m_ToggleAddPoint->setChecked(false);
 }
diff --git a/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp b/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp
index 34cb7dab3b..be85406e02 100644
--- a/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp
@@ -1,266 +1,266 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkSliceWidget.h"
 #include "QmitkStepperAdapter.h"
 #include "mitkCameraController.h"
 #include "mitkImage.h"
 #include "mitkNodePredicateDataType.h"
 #include <QMenu>
 #include <QMouseEvent>
 #include <mitkCameraController.h>
 #include <mitkProportionalTimeGeometry.h>
 
 QmitkSliceWidget::QmitkSliceWidget(QWidget *parent, const char *name, Qt::WindowFlags f) : QWidget(parent, f)
 {
   this->setupUi(this);
 
   if (name != nullptr)
     this->setObjectName(name);
 
   popUp = new QMenu(this);
   popUp->addAction("Axial");
-  popUp->addAction("Frontal");
+  popUp->addAction("Coronal");
   popUp->addAction("Sagittal");
 
   QObject::connect(popUp, SIGNAL(triggered(QAction *)), this, SLOT(ChangeView(QAction *)));
   setPopUpEnabled(false);
 
   m_SlicedGeometry = nullptr;
   m_View = mitk::SliceNavigationController::Axial;
 
   QHBoxLayout *hlayout = new QHBoxLayout(container);
   hlayout->setMargin(0);
 
   // create widget
   QString composedName("QmitkSliceWidget::");
   if (!this->objectName().isEmpty())
     composedName += this->objectName();
   else
     composedName += "QmitkGLWidget";
   m_RenderWindow = new QmitkRenderWindow(container, composedName);
   m_Renderer = m_RenderWindow->GetRenderer();
   hlayout->addWidget(m_RenderWindow);
 
   new QmitkStepperAdapter(m_NavigatorWidget, m_RenderWindow->GetSliceNavigationController()->GetSlice(), "navigation");
 
   SetLevelWindowEnabled(true);
 }
 
 mitk::VtkPropRenderer *QmitkSliceWidget::GetRenderer()
 {
   return m_Renderer;
 }
 
 QFrame *QmitkSliceWidget::GetSelectionFrame()
 {
   return SelectionFrame;
 }
 
 void QmitkSliceWidget::SetDataStorage(mitk::StandaloneDataStorage::Pointer storage)
 {
   m_DataStorage = storage;
   m_Renderer->SetDataStorage(m_DataStorage);
 }
 
 mitk::StandaloneDataStorage *QmitkSliceWidget::GetDataStorage()
 {
   return m_DataStorage;
 }
 
 void QmitkSliceWidget::SetData(mitk::DataStorage::SetOfObjects::ConstIterator it)
 {
   SetData(it->Value(), m_View);
 }
 
 void QmitkSliceWidget::SetData(mitk::DataStorage::SetOfObjects::ConstIterator it,
                                mitk::SliceNavigationController::ViewDirection view)
 {
   SetData(it->Value(), view);
 }
 
 void QmitkSliceWidget::SetData(mitk::DataNode::Pointer node)
 {
   try
   {
     if (m_DataStorage.IsNotNull())
     {
       m_DataStorage->Add(node);
     }
   }
   catch (...)
   {
   }
   SetData(node, m_View);
 }
 
 void QmitkSliceWidget::SetData(mitk::DataNode::Pointer node, mitk::SliceNavigationController::ViewDirection view)
 {
   mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
 
   if (image.IsNull())
   {
     MITK_WARN << "QmitkSliceWidget data is not an image!";
     return;
   }
 
   m_SlicedGeometry = image->GetSlicedGeometry();
   this->InitWidget(view);
 }
 
 void QmitkSliceWidget::InitWidget(mitk::SliceNavigationController::ViewDirection viewDirection)
 {
   m_View = viewDirection;
 
   mitk::SliceNavigationController *controller = m_RenderWindow->GetSliceNavigationController();
 
   if (viewDirection == mitk::SliceNavigationController::Axial)
   {
     controller->SetViewDirection(mitk::SliceNavigationController::Axial);
   }
-  else if (viewDirection == mitk::SliceNavigationController::Frontal)
+  else if (viewDirection == mitk::SliceNavigationController::Coronal)
   {
-    controller->SetViewDirection(mitk::SliceNavigationController::Frontal);
+    controller->SetViewDirection(mitk::SliceNavigationController::Coronal);
   }
   // init sagittal view
   else
   {
     controller->SetViewDirection(mitk::SliceNavigationController::Sagittal);
   }
 
   if (m_SlicedGeometry.IsNull())
   {
     return;
   }
 
   mitk::BaseGeometry::Pointer geometry = static_cast<mitk::BaseGeometry *>(m_SlicedGeometry->Clone().GetPointer());
 
   const mitk::BoundingBox::Pointer boundingbox = m_DataStorage->ComputeVisibleBoundingBox(GetRenderer(), nullptr);
 
   if (boundingbox->GetPoints()->Size() > 0)
   {
     // let's see if we have data with a limited live-span ...
     mitk::TimeBounds timebounds = m_DataStorage->ComputeTimeBounds(GetRenderer(), nullptr);
 
     mitk::ProportionalTimeGeometry::Pointer timeGeometry = mitk::ProportionalTimeGeometry::New();
     timeGeometry->Initialize(geometry, 1);
 
     {
       timeGeometry->SetFirstTimePoint(timebounds[0]);
       timeGeometry->SetStepDuration(1.0);
     }
 
     if (timeGeometry->GetBoundingBoxInWorld()->GetDiagonalLength2() >= mitk::eps)
     {
       controller->SetInputWorldTimeGeometry(timeGeometry);
       controller->Update();
     }
   }
 
   GetRenderer()->GetCameraController()->Fit();
   mitk::RenderingManager::GetInstance()->RequestUpdate(GetRenderer()->GetRenderWindow());
 }
 
 void QmitkSliceWidget::UpdateGL()
 {
   GetRenderer()->GetCameraController()->Fit();
   mitk::RenderingManager::GetInstance()->RequestUpdate(GetRenderer()->GetRenderWindow());
 }
 
 void QmitkSliceWidget::mousePressEvent(QMouseEvent *e)
 {
   if (e->button() == Qt::RightButton && popUpEnabled)
   {
     popUp->popup(QCursor::pos());
   }
 }
 
 void QmitkSliceWidget::wheelEvent(QWheelEvent *e)
 {
   int val = m_NavigatorWidget->GetPos();
 
   if (e->orientation() * e->delta() > 0)
   {
     m_NavigatorWidget->SetPos(val + 1);
   }
   else
   {
     if (val > 0)
       m_NavigatorWidget->SetPos(val - 1);
   }
 }
 
 void QmitkSliceWidget::ChangeView(QAction *val)
 {
   if (val->text() == "Axial")
   {
     InitWidget(mitk::SliceNavigationController::Axial);
   }
-  else if (val->text() == "Frontal")
+  else if (val->text() == "Coronal")
   {
-    InitWidget(mitk::SliceNavigationController::Frontal);
+    InitWidget(mitk::SliceNavigationController::Coronal);
   }
   else if (val->text() == "Sagittal")
   {
     InitWidget(mitk::SliceNavigationController::Sagittal);
   }
 }
 
 void QmitkSliceWidget::setPopUpEnabled(bool b)
 {
   popUpEnabled = b;
 }
 
 QmitkSliderNavigatorWidget *QmitkSliceWidget::GetNavigatorWidget()
 {
   return m_NavigatorWidget;
 }
 
 void QmitkSliceWidget::SetLevelWindowEnabled(bool enable)
 {
   levelWindow->setEnabled(enable);
   if (!enable)
   {
     levelWindow->setMinimumWidth(0);
     levelWindow->setMaximumWidth(0);
   }
   else
   {
     levelWindow->setMinimumWidth(28);
     levelWindow->setMaximumWidth(28);
   }
 }
 
 bool QmitkSliceWidget::IsLevelWindowEnabled()
 {
   return levelWindow->isEnabled();
 }
 
 QmitkRenderWindow *QmitkSliceWidget::GetRenderWindow()
 {
   return m_RenderWindow;
 }
 
 mitk::SliceNavigationController *QmitkSliceWidget::GetSliceNavigationController() const
 {
   return m_RenderWindow->GetSliceNavigationController();
 }
 
 mitk::CameraRotationController *QmitkSliceWidget::GetCameraRotationController() const
 {
   return m_RenderWindow->GetCameraRotationController();
 }
 
 mitk::BaseController *QmitkSliceWidget::GetController() const
 {
   return m_RenderWindow->GetController();
 }
diff --git a/Modules/RT/include/mitkDoseImageVtkMapper2D.h b/Modules/RT/include/mitkDoseImageVtkMapper2D.h
index e376d228a1..b3736cafd3 100644
--- a/Modules/RT/include/mitkDoseImageVtkMapper2D.h
+++ b/Modules/RT/include/mitkDoseImageVtkMapper2D.h
@@ -1,303 +1,303 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKDoseImageVtkMapper2D2D_H_HEADER_INCLUDED
 #define MITKDoseImageVtkMapper2D2D_H_HEADER_INCLUDED
 
 //MITK
 #include <mitkCommon.h>
 #include <MitkRTExports.h>
 
 //MITK Rendering
 #include "mitkBaseRenderer.h"
 #include "mitkVtkMapper.h"
 #include "mitkExtractSliceFilter.h"
 
 //VTK
 #include <vtkSmartPointer.h>
 #include <vtkPropAssembly.h>
 #include <vtkCellArray.h>
 
 class vtkActor;
 class vtkPolyDataMapper;
 class vtkPlaneSource;
 class vtkImageData;
 class vtkLookupTable;
 class vtkImageExtractComponents;
 class vtkImageReslice;
 class vtkImageChangeInformation;
 class vtkPoints;
 class vtkMitkThickSlicesFilter;
 class vtkPolyData;
 class vtkMitkApplyLevelWindowToRGBFilter;
 class vtkMitkLevelWindowFilter;
 
 namespace mitk {
 
   /** \brief Mapper to resample and display 2D slices of a 3D image.
   *
   * First, the image is resliced by means of vtkImageReslice. The volume image
   * serves as input to the mapper in addition to spatial placement of the slice and a few other
   * properties such as thick slices. This code was already present in the old version
   * (mitkImageMapperGL2D).
   *
   * Next, the obtained slice (m_ReslicedImage) is put into a vtkMitkLevelWindowFilter
   * and the scalar levelwindow, opacity levelwindow and optional clipping to
   * local image bounds are applied
   *
   * Next, the output of the vtkMitkLevelWindowFilter is used to create a texture
   * (m_Texture) and a plane onto which the texture is rendered (m_Plane). For
   * mapping purposes, a vtkPolyDataMapper (m_Mapper) is utilized. Orthographic
   * projection is applied to create the effect of a 2D image. The mapper and the
   * texture are assigned to the actor (m_Actor) which is passed to the VTK rendering
   * pipeline via the method GetVtkProp().
   *
   * In order to transform the textured plane to the correct position in space, the
   * same transformation as used for reslicing is applied to both the camera and the
   * vtkActor. All important steps are explained in more detail below. The resulting
   * 2D image (by reslicing the underlying 3D input image appropriately) can either
   * be directly rendered in a 2D view or just be calculated to be used later by another
   * rendering entity, e.g. in texture mapping in a 3D view.
   *
   * Properties that can be set for images and influence the imageMapper2D are:
   *
   *   - \b "opacity": (FloatProperty) Opacity of the image
   *   - \b "color": (ColorProperty) Color of the image
   *   - \b "LookupTable": (mitkLookupTableProperty) If this property is set,
   *          the default lookuptable will be ignored and the "LookupTable" value
   *          will be used instead.
   *   - \b "Image Rendering.Mode": This property decides which mode is used to render images. (E.g. if a lookup table or a transferfunction is applied). Detailed documentation about the modes can be found here: \link mitk::RenderingModeProperty \endlink
   *   - \b "Image Rendering.Transfer Function": (mitkTransferFunctionProperty) If this
   *          property is set, a color transferfunction will be used to color the image.
   *   - \b "binary": (BoolProperty) is the image a binary image or not
   *   - \b "outline binary": (BoolProperty) show outline of the image or not
   *   - \b "texture interpolation": (BoolProperty) texture interpolation of the image
   *   - \b "reslice interpolation": (VtkResliceInterpolationProperty) reslice interpolation of the image
   *   - \b "in plane resample extent by geometry": (BoolProperty) Do it or not
   *   - \b "bounding box": (BoolProperty) Is the Bounding Box of the image shown or not
   *   - \b "layer": (IntProperty) Layer of the image
   *   - \b "volume annotation color": (ColorProperty) color of the volume annotation, TODO has to be reimplemented
   *   - \b "volume annotation unit": (StringProperty) annotation unit as string (does not implicit convert the unit!)
   unit is ml or cm3, TODO has to be reimplemented
 
   * The default properties are:
 
   *   - \b "opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite )
   *   - \b "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite )
   *   - \b "binary", mitk::BoolProperty::New( true ), renderer, overwrite )
   *   - \b "outline binary", mitk::BoolProperty::New( false ), renderer, overwrite )
   *   - \b "texture interpolation", mitk::BoolProperty::New( false ) )
   *   - \b "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() )
   *   - \b "in plane resample extent by geometry", mitk::BoolProperty::New( false ) )
   *   - \b "bounding box", mitk::BoolProperty::New( false ) )
   *   - \b "layer", mitk::IntProperty::New(10), renderer, overwrite)
   *   - \b "Image Rendering.Transfer Function":  Default color transfer function for CTs
   *   - \b "LookupTable": Rainbow color.
 
   * If the modality-property is set for an image, the mapper uses modality-specific default properties,
   * e.g. color maps, if they are defined.
 
   * \ingroup Mapper
   */
   class MITKRT_EXPORT DoseImageVtkMapper2D : public VtkMapper
   {
 
   public:
     /** Standard class typedefs. */
     mitkClassMacro( DoseImageVtkMapper2D,VtkMapper );
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       /** \brief Get the Image to map */
       const mitk::Image *GetInput(void);
 
     /** \brief Checks whether this mapper needs to update itself and generate
     * data. */
     void Update(mitk::BaseRenderer * renderer) override;
 
     //### methods of MITK-VTK rendering pipeline
     vtkProp* GetVtkProp(mitk::BaseRenderer* renderer) override;
     //### end of methods of MITK-VTK rendering pipeline
 
 
     /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
     /**
-    * To render transveral, coronal, and sagittal, the mapper is called three times.
+    * To render axial, coronal, and sagittal, the mapper is called three times.
     * For performance reasons, the corresponding data for each view is saved in the
     * internal helper class LocalStorage. This allows rendering n views with just
     * 1 mitkMapper using n vtkMapper.
     * */
     class MITKRT_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
     {
     public:
       /** \brief Actor of a 2D render window. */
       vtkSmartPointer<vtkActor> m_Actor;
 
       vtkSmartPointer<vtkPropAssembly> m_Actors;
       /** \brief Mapper of a 2D render window. */
       vtkSmartPointer<vtkPolyDataMapper> m_Mapper;
       vtkSmartPointer<vtkImageExtractComponents> m_VectorComponentExtractor;
       /** \brief Current slice of a 2D render window.*/
       vtkSmartPointer<vtkImageData> m_ReslicedImage;
       /** \brief Empty vtkPolyData that is set when rendering geometry does not
       *   intersect the image geometry.
       *   \warning This member variable is set to nullptr,
       *   if no image geometry is inside the plane geometry
       *   of the respective render window. Any user of this
       *   slice has to check whether it is set to nullptr!
       */
       vtkSmartPointer<vtkPolyData> m_EmptyPolyData;
       /** \brief Plane on which the slice is rendered as texture. */
       vtkSmartPointer<vtkPlaneSource> m_Plane;
       /** \brief The texture which is used to render the current slice. */
       vtkSmartPointer<vtkTexture> m_Texture;
       /** \brief The lookuptables for colors and level window */
       vtkSmartPointer<vtkLookupTable> m_DefaultLookupTable;
       vtkSmartPointer<vtkLookupTable> m_BinaryLookupTable;
       vtkSmartPointer<vtkLookupTable> m_ColorLookupTable;
       /** \brief The actual reslicer (one per renderer) */
       mitk::ExtractSliceFilter::Pointer m_Reslicer;
       /** \brief Filter for thick slices */
       vtkSmartPointer<vtkMitkThickSlicesFilter> m_TSFilter;
       /** \brief PolyData object containg all lines/points needed for outlining the contour.
       This container is used to save a computed contour for the next rendering execution.
       For instance, if you zoom or pann, there is no need to recompute the contour. */
       vtkSmartPointer<vtkPolyData> m_OutlinePolyData;
 
       /** \brief Timestamp of last update of stored data. */
       itk::TimeStamp m_LastUpdateTime;
 
       /** \brief mmPerPixel relation between pixel and mm. (World spacing).*/
       mitk::ScalarType* m_mmPerPixel;
 
       /** \brief This filter is used to apply the level window to Grayvalue and RBG(A) images. */
       vtkSmartPointer<vtkMitkLevelWindowFilter> m_LevelWindowFilter;
 
       /** \brief Default constructor of the local storage. */
       LocalStorage();
       /** \brief Default deconstructor of the local storage. */
       ~LocalStorage() override;
     };
 
     /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
     mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
     /** \brief Get the LocalStorage corresponding to the current renderer. */
     LocalStorage* GetLocalStorage(mitk::BaseRenderer* renderer);
 
     /** \brief Set the default properties for general image rendering. */
     static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = nullptr, bool overwrite = false);
 
     /** \brief This method switches between different rendering modes (e.g. use a lookup table or a transfer function).
     * Detailed documentation about the modes can be found here: \link mitk::RenderingModeProperty \endlink
     */
     void ApplyRenderingMode(mitk::BaseRenderer *renderer);
 
   protected:
     /** \brief Transforms the actor to the actual position in 3D.
     *   \param renderer The current renderer corresponding to the render window.
     */
     void TransformActor(mitk::BaseRenderer* renderer);
 
     /** \brief Generates a plane according to the size of the resliced image in milimeters.
     *
     * In VTK a vtkPlaneSource is defined through three points. The origin and two
     * points defining the axes of the plane (see VTK documentation). The origin is
     * set to (xMin; yMin; Z), where xMin and yMin are the minimal bounds of the
     * resliced image in space. Z is relevant for blending and the layer property.
     * The center of the plane (C) is also the center of the view plane (cf. the image above).
     *
     * \note For the standard MITK view with three 2D render windows showing three
     * different slices, three such planes are generated. All these planes are generated
     * in the XY-plane (even if they depict a YZ-slice of the volume).
     *
     */
     void GeneratePlane(mitk::BaseRenderer* renderer, double planeBounds[6]);
 
     /** \brief Generates a vtkPolyData object containing the outline of a given binary slice.
     \param renderer: Pointer to the renderer containing the needed information
     \note This code is based on code from the iil library.
     */
     vtkSmartPointer<vtkPolyData> CreateOutlinePolyData(mitk::BaseRenderer* renderer);
 
     /** Default constructor */
     DoseImageVtkMapper2D();
     /** Default deconstructor */
     ~DoseImageVtkMapper2D() override;
 
     /** \brief Does the actual resampling, without rendering the image yet.
     * All the data is generated inside this method. The vtkProp (or Actor)
     * is filled with content (i.e. the resliced image).
     *
     * After generation, a 4x4 transformation matrix(t) of the current slice is obtained
     * from the vtkResliceImage object via GetReslicesAxis(). This matrix is
     * applied to each textured plane (actor->SetUserTransform(t)) to transform everything
     * to the actual 3D position (cf. the following image).
     *
     * \image html cameraPositioning3D.png
     *
     */
     void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
 
     /** \brief This method uses the vtkCamera clipping range and the layer property
     * to calcualte the depth of the object (e.g. image or contour). The depth is used
     * to keep the correct order for the final VTK rendering.*/
     float CalculateLayerDepth(mitk::BaseRenderer* renderer);
 
     /** \brief This method applies (or modifies) the lookuptable for all types of images.
     * \warning To use the lookup table, the property 'Lookup Table' must be set and a 'Image Rendering.Mode'
     * which uses the lookup table must be set.
     */
     void ApplyLookuptable(mitk::BaseRenderer* renderer);
 
     /** \brief This method applies a color transfer function.
     * Internally, a vtkColorTransferFunction is used. This is usefull for coloring continous
     * images (e.g. float)
     * \warning To use the color transfer function, the property 'Image Rendering.Transfer Function' must be set and a 'Image Rendering.Mode' which uses the color transfer function must be set.
     */
     void ApplyColorTransferFunction(mitk::BaseRenderer* renderer);
 
     /**
     * @brief ApplyLevelWindow Apply the level window for the given renderer.
     * \warning To use the level window, the property 'LevelWindow' must be set and a 'Image Rendering.Mode' which uses the level window must be set.
     * @param renderer Level window for which renderer?
     */
     void ApplyLevelWindow(mitk::BaseRenderer* renderer);
 
     /** \brief Set the color of the image/polydata */
     void ApplyColor( mitk::BaseRenderer* renderer );
 
     /** \brief Set the opacity of the actor. */
     void ApplyOpacity( mitk::BaseRenderer* renderer );
 
     /**
     * \brief Calculates whether the given rendering geometry intersects the
     * given SlicedGeometry3D.
     *
     * This method checks if the given PlaneGeometry intersects the given
     * SlicedGeometry3D. It calculates the distance of the PlaneGeometry to all
     * 8 cornerpoints of the SlicedGeometry3D. If all distances have the same
     * sign (all positive or all negative) there is no intersection.
     * If the distances have different sign, there is an intersection.
     **/
     bool RenderingGeometryIntersectsImage( const PlaneGeometry* renderingGeometry, SlicedGeometry3D* imageGeometry );
 
   private:
     void CreateLevelOutline(mitk::BaseRenderer* renderer, const mitk::IsoDoseLevel* level, float pref, vtkSmartPointer<vtkPoints> points, vtkSmartPointer<vtkCellArray> lines,  vtkSmartPointer<vtkUnsignedCharArray> colors);
 
   };
 
 } // namespace mitk
 
 #endif /* MITKDoseImageVtkMapper2D_H_HEADER_INCLUDED_C10E906E */
diff --git a/Modules/RT/src/mitkDoseImageVtkMapper2D.cpp b/Modules/RT/src/mitkDoseImageVtkMapper2D.cpp
index 1bbfcf7867..e3698ba136 100644
--- a/Modules/RT/src/mitkDoseImageVtkMapper2D.cpp
+++ b/Modules/RT/src/mitkDoseImageVtkMapper2D.cpp
@@ -1,1163 +1,1163 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // MITK
 #include "mitkImageStatisticsHolder.h"
 #include "mitkPlaneClipping.h"
 #include "mitkPropertyNameHelper.h"
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkDataNode.h>
 #include <mitkImageSliceSelector.h>
 #include <mitkIsoDoseLevelSetProperty.h>
 #include <mitkIsoDoseLevelVectorProperty.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkPixelType.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkProperties.h>
 #include <mitkRTConstants.h>
 #include <mitkRenderingModeProperty.h>
 #include <mitkResliceMethodProperty.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 
 // MITK Rendering
 #include "mitkDoseImageVtkMapper2D.h"
 
 #include "vtkMitkLevelWindowFilter.h"
 #include "vtkMitkThickSlicesFilter.h"
 #include "vtkNeverTranslucentTexture.h"
 
 // VTK
 #include <vtkCamera.h>
 #include <vtkCellData.h>
 #include <vtkColorTransferFunction.h>
 #include <vtkGeneralTransform.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkImageData.h>
 #include <vtkImageExtractComponents.h>
 #include <vtkImageReslice.h>
 #include <vtkLookupTable.h>
 #include <vtkMatrix4x4.h>
 #include <vtkPlaneSource.h>
 #include <vtkPoints.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
 #include <vtkTransform.h>
 #include <vtkUnsignedCharArray.h>
 
 // ITK
 #include <itkRGBAPixel.h>
 
 mitk::DoseImageVtkMapper2D::DoseImageVtkMapper2D()
 {
 }
 
 mitk::DoseImageVtkMapper2D::~DoseImageVtkMapper2D()
 {
   // The 3D RW Mapper (PlaneGeometryDataVtkMapper3D) is listening to this event,
   // in order to delete the images from the 3D RW.
   this->InvokeEvent(itk::DeleteEvent());
 }
 
 // set the two points defining the textured plane according to the dimension and spacing
 void mitk::DoseImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer *renderer, double planeBounds[6])
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   float depth = this->CalculateLayerDepth(renderer);
   // Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
   // plane size in crosshair rotation and swivel mode.
   localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
   // These two points define the axes of the plane in combination with the origin.
   // Point 1 is the x-axis and point 2 the y-axis.
-  // Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
+  // Each plane is transformed according to the view (axial, coronal and sagittal) afterwards.
   localStorage->m_Plane->SetPoint1(planeBounds[1], planeBounds[2], depth); // P1: (xMax, yMin, depth)
   localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); // P2: (xMin, yMax, depth)
 }
 
 float mitk::DoseImageVtkMapper2D::CalculateLayerDepth(mitk::BaseRenderer *renderer)
 {
   // get the clipping range to check how deep into z direction we can render images
   double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
 
   // Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
   float depth = -maxRange * 0.01; // divide by 100
   int layer = 0;
   GetDataNode()->GetIntProperty("layer", layer, renderer);
   // add the layer property for each image to render images with a higher layer on top of the others
   depth += layer * 10; //*10: keep some room for each image (e.g. for ODFs in between)
   if (depth > 0.0f)
   {
     depth = 0.0f;
     MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
   }
   return depth;
 }
 
 const mitk::Image *mitk::DoseImageVtkMapper2D::GetInput(void)
 {
   return static_cast<const mitk::Image *>(GetDataNode()->GetData());
 }
 
 vtkProp *mitk::DoseImageVtkMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   // return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Actors;
 }
 
 void mitk::DoseImageVtkMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   mitk::Image *input = const_cast<mitk::Image *>(this->GetInput());
   mitk::DataNode *datanode = this->GetDataNode();
 
   if (input == nullptr || input->IsInitialized() == false)
   {
     return;
   }
 
   // check if there is a valid worldGeometry
   const PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
   if ((worldGeometry == nullptr) || (!worldGeometry->IsValid()) || (!worldGeometry->HasReferenceGeometry()))
   {
     return;
   }
 
   input->Update();
 
   // early out if there is no intersection of the current rendering geometry
   // and the geometry of the image that is to be rendered.
   if (!RenderingGeometryIntersectsImage(worldGeometry, input->GetSlicedGeometry()))
   {
     // set image to nullptr, to clear the texture in 3D, because
     // the latest image is used there if the plane is out of the geometry
     // see bug-13275
     localStorage->m_ReslicedImage = nullptr;
     localStorage->m_Mapper->SetInputData(localStorage->m_EmptyPolyData);
     return;
   }
 
   // set main input for ExtractSliceFilter
   localStorage->m_Reslicer->SetInput(input);
   localStorage->m_Reslicer->SetWorldGeometry(worldGeometry);
   localStorage->m_Reslicer->SetTimeStep(this->GetTimestep());
 
   // set the transformation of the image to adapt reslice axis
   localStorage->m_Reslicer->SetResliceTransformByGeometry(
     input->GetTimeGeometry()->GetGeometryForTimeStep(this->GetTimestep()));
 
   // is the geometry of the slice based on the input image or the worldgeometry?
   bool inPlaneResampleExtentByGeometry = false;
   datanode->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
   localStorage->m_Reslicer->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
 
   // Initialize the interpolation mode for resampling; switch to nearest
   // neighbor if the input image is too small.
   if ((input->GetDimension() >= 3) && (input->GetDimension(2) > 1))
   {
     VtkResliceInterpolationProperty *resliceInterpolationProperty;
     datanode->GetProperty(resliceInterpolationProperty, "reslice interpolation");
 
     int interpolationMode = VTK_RESLICE_NEAREST;
     if (resliceInterpolationProperty != nullptr)
     {
       interpolationMode = resliceInterpolationProperty->GetInterpolation();
     }
 
     switch (interpolationMode)
     {
       case VTK_RESLICE_NEAREST:
         localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
         break;
       case VTK_RESLICE_LINEAR:
         localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_LINEAR);
         break;
       case VTK_RESLICE_CUBIC:
         localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_CUBIC);
         break;
     }
   }
   else
   {
     localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
   }
 
   // set the vtk output property to true, makes sure that no unneeded mitk image convertion
   // is done.
   localStorage->m_Reslicer->SetVtkOutputRequest(true);
 
   // Thickslicing
   int thickSlicesMode = 0;
   int thickSlicesNum = 1;
   // Thick slices parameters
   if (input->GetPixelType().GetNumberOfComponents() == 1) // for now only single component are allowed
   {
     DataNode *dn = renderer->GetCurrentWorldPlaneGeometryNode();
     if (dn)
     {
       ResliceMethodProperty *resliceMethodEnumProperty = nullptr;
 
       if (dn->GetProperty(resliceMethodEnumProperty, "reslice.thickslices") && resliceMethodEnumProperty)
         thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
 
       IntProperty *intProperty = nullptr;
       if (dn->GetProperty(intProperty, "reslice.thickslices.num") && intProperty)
       {
         thickSlicesNum = intProperty->GetValue();
         if (thickSlicesNum < 1)
           thickSlicesNum = 1;
         if (thickSlicesNum > 10)
           thickSlicesNum = 10;
       }
     }
     else
     {
       MITK_WARN << "no associated widget plane data tree node found";
     }
   }
 
   const PlaneGeometry *planeGeometry = dynamic_cast<const PlaneGeometry *>(worldGeometry);
 
   if (thickSlicesMode > 0)
   {
     double dataZSpacing = 1.0;
 
     Vector3D normInIndex, normal;
 
     if (planeGeometry != nullptr)
     {
       normal = planeGeometry->GetNormal();
     }
     else
     {
       const mitk::AbstractTransformGeometry *abstractGeometry =
         dynamic_cast<const AbstractTransformGeometry *>(worldGeometry);
       if (abstractGeometry != nullptr)
         normal = abstractGeometry->GetPlane()->GetNormal();
       else
         return; // no fitting geometry set
     }
     normal.Normalize();
 
     input->GetTimeGeometry()->GetGeometryForTimeStep(this->GetTimestep())->WorldToIndex(normal, normInIndex);
 
     dataZSpacing = 1.0 / normInIndex.GetNorm();
 
     localStorage->m_Reslicer->SetOutputDimensionality(3);
     localStorage->m_Reslicer->SetOutputSpacingZDirection(dataZSpacing);
     localStorage->m_Reslicer->SetOutputExtentZDirection(-thickSlicesNum, 0 + thickSlicesNum);
 
     // Do the reslicing. Modified() is called to make sure that the reslicer is
     // executed even though the input geometry information did not change; this
     // is necessary when the input /em data, but not the /em geometry changes.
     localStorage->m_TSFilter->SetThickSliceMode(thickSlicesMode - 1);
     localStorage->m_TSFilter->SetInputData(localStorage->m_Reslicer->GetVtkOutput());
 
     // vtkFilter=>mitkFilter=>vtkFilter update mechanism will fail without calling manually
     localStorage->m_Reslicer->Modified();
     localStorage->m_Reslicer->Update();
 
     localStorage->m_TSFilter->Modified();
     localStorage->m_TSFilter->Update();
     localStorage->m_ReslicedImage = localStorage->m_TSFilter->GetOutput();
   }
   else
   {
     // this is needed when thick mode was enable bevore. These variable have to be reset to default values
     localStorage->m_Reslicer->SetOutputDimensionality(2);
     localStorage->m_Reslicer->SetOutputSpacingZDirection(1.0);
     localStorage->m_Reslicer->SetOutputExtentZDirection(0, 0);
 
     localStorage->m_Reslicer->Modified();
     // start the pipeline with updating the largest possible, needed if the geometry of the input has changed
     localStorage->m_Reslicer->UpdateLargestPossibleRegion();
     localStorage->m_ReslicedImage = localStorage->m_Reslicer->GetVtkOutput();
   }
 
   // Bounds information for reslicing (only reuqired if reference geometry
   // is present)
   // this used for generating a vtkPLaneSource with the right size
   double sliceBounds[6];
   for (int i = 0; i < 6; ++i)
   {
     sliceBounds[i] = 0.0;
   }
   localStorage->m_Reslicer->GetClippedPlaneBounds(sliceBounds);
 
   // get the spacing of the slice
   localStorage->m_mmPerPixel = localStorage->m_Reslicer->GetOutputSpacing();
 
   // calculate minimum bounding rect of IMAGE in texture
   {
     double textureClippingBounds[6];
     for (int i = 0; i < 6; ++i)
     {
       textureClippingBounds[i] = 0.0;
     }
     // Calculate the actual bounds of the transformed plane clipped by the
     // dataset bounding box; this is required for drawing the texture at the
     // correct position during 3D mapping.
     mitk::PlaneClipping::CalculateClippedPlaneBounds(input->GetGeometry(), planeGeometry, textureClippingBounds);
 
     textureClippingBounds[0] = static_cast<int>(textureClippingBounds[0] / localStorage->m_mmPerPixel[0] + 0.5);
     textureClippingBounds[1] = static_cast<int>(textureClippingBounds[1] / localStorage->m_mmPerPixel[0] + 0.5);
     textureClippingBounds[2] = static_cast<int>(textureClippingBounds[2] / localStorage->m_mmPerPixel[1] + 0.5);
     textureClippingBounds[3] = static_cast<int>(textureClippingBounds[3] / localStorage->m_mmPerPixel[1] + 0.5);
 
     // clipping bounds for cutting the image
     localStorage->m_LevelWindowFilter->SetClippingBounds(textureClippingBounds);
   }
 
   // get the number of scalar components to distinguish between different image types
   int numberOfComponents = localStorage->m_ReslicedImage->GetNumberOfScalarComponents();
   // get the showIsoLines property
   bool showIsoLines = false;
   datanode->GetBoolProperty("dose.showIsoLines", showIsoLines, renderer);
 
   if (showIsoLines) // contour rendering
   {
     // generate contours/outlines
     localStorage->m_OutlinePolyData = CreateOutlinePolyData(renderer);
 
     float binaryOutlineWidth(1.0);
     if (datanode->GetFloatProperty("outline width", binaryOutlineWidth, renderer))
     {
       if (localStorage->m_Actors->GetNumberOfPaths() > 1)
       {
         float binaryOutlineShadowWidth(1.5);
         datanode->GetFloatProperty("outline shadow width", binaryOutlineShadowWidth, renderer);
 
         dynamic_cast<vtkActor *>(localStorage->m_Actors->GetParts()->GetItemAsObject(0))
           ->GetProperty()
           ->SetLineWidth(binaryOutlineWidth * binaryOutlineShadowWidth);
       }
 
       localStorage->m_Actor->GetProperty()->SetLineWidth(binaryOutlineWidth);
     }
   }
   else
   {
     localStorage->m_ReslicedImage = nullptr;
     localStorage->m_Mapper->SetInputData(localStorage->m_EmptyPolyData);
     return;
   }
 
   this->ApplyOpacity(renderer);
   this->ApplyRenderingMode(renderer);
 
   // do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
   localStorage->m_Texture->SetColorModeToDirectScalars();
 
   int displayedComponent = 0;
 
   if (datanode->GetIntProperty("Image.Displayed Component", displayedComponent, renderer) && numberOfComponents > 1)
   {
     localStorage->m_VectorComponentExtractor->SetComponents(displayedComponent);
     localStorage->m_VectorComponentExtractor->SetInputData(localStorage->m_ReslicedImage);
 
     localStorage->m_LevelWindowFilter->SetInputConnection(localStorage->m_VectorComponentExtractor->GetOutputPort(0));
   }
   else
   {
     // connect the input with the levelwindow filter
     localStorage->m_LevelWindowFilter->SetInputData(localStorage->m_ReslicedImage);
   }
 
   // check for texture interpolation property
   bool textureInterpolation = false;
   GetDataNode()->GetBoolProperty("texture interpolation", textureInterpolation, renderer);
 
   // set the interpolation modus according to the property
   localStorage->m_Texture->SetInterpolate(textureInterpolation);
 
   // connect the texture with the output of the levelwindow filter
   localStorage->m_Texture->SetInputConnection(localStorage->m_LevelWindowFilter->GetOutputPort());
 
   this->TransformActor(renderer);
 
   vtkActor *contourShadowActor = dynamic_cast<vtkActor *>(localStorage->m_Actors->GetParts()->GetItemAsObject(0));
 
   if (showIsoLines) // connect the mapper with the polyData which contains the lines
   {
     // We need the contour for the binary outline property as actor
     localStorage->m_Mapper->SetInputData(localStorage->m_OutlinePolyData);
     localStorage->m_Actor->SetTexture(nullptr); // no texture for contours
 
     bool binaryOutlineShadow(false);
     datanode->GetBoolProperty("outline binary shadow", binaryOutlineShadow, renderer);
 
     if (binaryOutlineShadow)
       contourShadowActor->SetVisibility(true);
     else
       contourShadowActor->SetVisibility(false);
   }
   else
   { // Connect the mapper with the input texture. This is the standard case.
     // setup the textured plane
     this->GeneratePlane(renderer, sliceBounds);
     // set the plane as input for the mapper
     localStorage->m_Mapper->SetInputConnection(localStorage->m_Plane->GetOutputPort());
     // set the texture for the actor
 
     localStorage->m_Actor->SetTexture(localStorage->m_Texture);
     contourShadowActor->SetVisibility(false);
   }
 
   // We have been modified => save this for next Update()
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::DoseImageVtkMapper2D::ApplyLevelWindow(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
 
   LevelWindow levelWindow;
   this->GetDataNode()->GetLevelWindow(levelWindow, renderer, "levelwindow");
   localStorage->m_LevelWindowFilter->GetLookupTable()->SetRange(levelWindow.GetLowerWindowBound(),
                                                                 levelWindow.GetUpperWindowBound());
 
   mitk::LevelWindow opacLevelWindow;
   if (this->GetDataNode()->GetLevelWindow(opacLevelWindow, renderer, "opaclevelwindow"))
   {
     // pass the opaque level window to the filter
     localStorage->m_LevelWindowFilter->SetMinOpacity(opacLevelWindow.GetLowerWindowBound());
     localStorage->m_LevelWindowFilter->SetMaxOpacity(opacLevelWindow.GetUpperWindowBound());
   }
   else
   {
     // no opaque level window
     localStorage->m_LevelWindowFilter->SetMinOpacity(0.0);
     localStorage->m_LevelWindowFilter->SetMaxOpacity(255.0);
   }
 }
 
 void mitk::DoseImageVtkMapper2D::ApplyColor(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
 
   float rgb[3] = {1.0f, 1.0f, 1.0f};
 
   // check for color prop and use it for rendering if it exists
   // binary image hovering & binary image selection
   bool hover = false;
   bool selected = false;
   GetDataNode()->GetBoolProperty("binaryimage.ishovering", hover, renderer);
   GetDataNode()->GetBoolProperty("selected", selected, renderer);
   if (hover && !selected)
   {
     mitk::ColorProperty::Pointer colorprop =
       dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("binaryimage.hoveringcolor", renderer));
     if (colorprop.IsNotNull())
     {
       memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float));
     }
     else
     {
       GetDataNode()->GetColor(rgb, renderer, "color");
     }
   }
   if (selected)
   {
     mitk::ColorProperty::Pointer colorprop =
       dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("binaryimage.selectedcolor", renderer));
     if (colorprop.IsNotNull())
     {
       memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float));
     }
     else
     {
       GetDataNode()->GetColor(rgb, renderer, "color");
     }
   }
   if (!hover && !selected)
   {
     GetDataNode()->GetColor(rgb, renderer, "color");
   }
 
   double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; // conversion to double for VTK
   dynamic_cast<vtkActor *>(localStorage->m_Actors->GetParts()->GetItemAsObject(0))->GetProperty()->SetColor(rgbConv);
   localStorage->m_Actor->GetProperty()->SetColor(rgbConv);
 
   if (localStorage->m_Actors->GetParts()->GetNumberOfItems() > 1)
   {
     float rgb[3] = {1.0f, 1.0f, 1.0f};
     mitk::ColorProperty::Pointer colorprop =
       dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("outline binary shadow color", renderer));
     if (colorprop.IsNotNull())
     {
       memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float));
     }
     double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; // conversion to double for VTK
     dynamic_cast<vtkActor *>(localStorage->m_Actors->GetParts()->GetItemAsObject(0))->GetProperty()->SetColor(rgbConv);
   }
 }
 
 void mitk::DoseImageVtkMapper2D::ApplyOpacity(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
   float opacity = 1.0f;
   // check for opacity prop and use it for rendering if it exists
   GetDataNode()->GetOpacity(opacity, renderer, "opacity");
   // set the opacity according to the properties
   localStorage->m_Actor->GetProperty()->SetOpacity(opacity);
   if (localStorage->m_Actors->GetParts()->GetNumberOfItems() > 1)
   {
     dynamic_cast<vtkActor *>(localStorage->m_Actors->GetParts()->GetItemAsObject(0))
       ->GetProperty()
       ->SetOpacity(opacity);
   }
 }
 
 void mitk::DoseImageVtkMapper2D::ApplyRenderingMode(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   bool binary = false;
   this->GetDataNode()->GetBoolProperty("binary", binary, renderer);
   if (binary) // is it a binary image?
   {
     // for binary images, we always use our default LuT and map every value to (0,1)
     // the opacity of 0 will always be 0.0. We never a apply a LuT/TfF nor a level window.
     localStorage->m_LevelWindowFilter->SetLookupTable(localStorage->m_BinaryLookupTable);
   }
   else
   {
     // all other image types can make use of the rendering mode
     int renderingMode = mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR;
     mitk::RenderingModeProperty::Pointer mode =
       dynamic_cast<mitk::RenderingModeProperty *>(this->GetDataNode()->GetProperty("Image Rendering.Mode", renderer));
     if (mode.IsNotNull())
     {
       renderingMode = mode->GetRenderingMode();
     }
     switch (renderingMode)
     {
       case mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR:
         MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_LookupTable_Color";
         this->ApplyLookuptable(renderer);
         this->ApplyLevelWindow(renderer);
         break;
       case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR:
         MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_ColorTransferFunction_Color";
         this->ApplyColorTransferFunction(renderer);
         this->ApplyLevelWindow(renderer);
         break;
       case mitk::RenderingModeProperty::LOOKUPTABLE_COLOR:
         MITK_DEBUG << "'Image Rendering.Mode' = LookupTable_Color";
         this->ApplyLookuptable(renderer);
         break;
       case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR:
         MITK_DEBUG << "'Image Rendering.Mode' = ColorTransferFunction_Color";
         this->ApplyColorTransferFunction(renderer);
         break;
       default:
         MITK_ERROR << "No valid 'Image Rendering.Mode' set. Using LOOKUPTABLE_LEVELWINDOW_COLOR instead.";
         this->ApplyLookuptable(renderer);
         this->ApplyLevelWindow(renderer);
         break;
     }
   }
   // we apply color for all images (including binaries).
   this->ApplyColor(renderer);
 }
 
 void mitk::DoseImageVtkMapper2D::ApplyLookuptable(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   vtkLookupTable *usedLookupTable = localStorage->m_ColorLookupTable;
 
   // If lookup table or transferfunction use is requested...
   mitk::LookupTableProperty::Pointer lookupTableProp =
     dynamic_cast<mitk::LookupTableProperty *>(this->GetDataNode()->GetProperty("LookupTable"));
 
   if (lookupTableProp.IsNotNull()) // is a lookuptable set?
   {
     usedLookupTable = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
   }
   else
   {
     //"Image Rendering.Mode was set to use a lookup table but there is no property 'LookupTable'.
     // A default (rainbow) lookup table will be used.
     // Here have to do nothing. Warning for the user has been removed, due to unwanted console output
     // in every interation of the rendering.
   }
   localStorage->m_LevelWindowFilter->SetLookupTable(usedLookupTable);
 }
 
 void mitk::DoseImageVtkMapper2D::ApplyColorTransferFunction(mitk::BaseRenderer *renderer)
 {
   mitk::TransferFunctionProperty::Pointer transferFunctionProp = dynamic_cast<mitk::TransferFunctionProperty *>(
     this->GetDataNode()->GetProperty("Image Rendering.Transfer Function", renderer));
 
   if (transferFunctionProp.IsNull())
   {
     MITK_ERROR << "'Image Rendering.Mode'' was set to use a color transfer function but there is no property 'Image "
                   "Rendering.Transfer Function'. Nothing will be done.";
     return;
   }
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   // pass the transfer function to our level window filter
   localStorage->m_LevelWindowFilter->SetLookupTable(transferFunctionProp->GetValue()->GetColorTransferFunction());
 }
 
 void mitk::DoseImageVtkMapper2D::Update(mitk::BaseRenderer *renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if (!visible)
   {
     return;
   }
 
   mitk::Image *data = const_cast<mitk::Image *>(this->GetInput());
   if (data == nullptr)
   {
     return;
   }
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep(renderer);
 
   // Check if time step is valid
   const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ((dataTimeGeometry == nullptr) || (dataTimeGeometry->CountTimeSteps() == 0) ||
       (!dataTimeGeometry->IsValidTimeStep(this->GetTimestep())))
   {
     return;
   }
 
   const DataNode *node = this->GetDataNode();
   data->UpdateOutputInformation();
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   // check if something important has changed and we need to rerender
   if ((localStorage->m_LastUpdateTime < node->GetMTime()) // was the node modified?
       ||
       (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) // Was the data modified?
       ||
       (localStorage->m_LastUpdateTime <
        renderer->GetCurrentWorldPlaneGeometryUpdateTime()) // was the geometry modified?
       ||
       (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()) ||
       (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) // was a property modified?
       ||
       (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()))
   {
     this->GenerateDataForRenderer(renderer);
   }
 
   // since we have checked that nothing important has changed, we can set
   // m_LastUpdateTime to the current time
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::DoseImageVtkMapper2D::SetDefaultProperties(mitk::DataNode *node,
                                                       mitk::BaseRenderer *renderer,
                                                       bool overwrite)
 {
   mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
 
   // Properties common for both images and segmentations
   node->AddProperty("depthOffset", mitk::FloatProperty::New(0.0), renderer, overwrite);
   node->AddProperty("outline binary", mitk::BoolProperty::New(false), renderer, overwrite);
   node->AddProperty("outline width", mitk::FloatProperty::New(1.0), renderer, overwrite);
   node->AddProperty("outline binary shadow", mitk::BoolProperty::New(false), renderer, overwrite);
   node->AddProperty("outline binary shadow color", ColorProperty::New(0.0, 0.0, 0.0), renderer, overwrite);
   node->AddProperty("outline shadow width", mitk::FloatProperty::New(1.5), renderer, overwrite);
   if (image->IsRotated())
     node->AddProperty("reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_CUBIC));
   else
     node->AddProperty("reslice interpolation", mitk::VtkResliceInterpolationProperty::New());
   node->AddProperty("texture interpolation",
                     mitk::BoolProperty::New(false)); // default value
   node->AddProperty("in plane resample extent by geometry", mitk::BoolProperty::New(false));
   node->AddProperty("bounding box", mitk::BoolProperty::New(false));
 
   mitk::RenderingModeProperty::Pointer renderingModeProperty = mitk::RenderingModeProperty::New();
   node->AddProperty("Image Rendering.Mode", renderingModeProperty);
 
   // Set default grayscale look-up table
   mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
   mitkLut->SetType(mitk::LookupTable::GRAYSCALE);
   mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
   mitkLutProp->SetLookupTable(mitkLut);
   node->SetProperty("LookupTable", mitkLutProp);
 
   std::string photometricInterpretation; // DICOM tag telling us how pixel values should be displayed
   if (node->GetStringProperty("dicom.pixel.PhotometricInterpretation", photometricInterpretation))
   {
     // modality provided by DICOM or other reader
     if (photometricInterpretation.find("MONOCHROME1") != std::string::npos) // meaning: display MINIMUM pixels as WHITE
     {
       // Set inverse grayscale look-up table
       mitkLut->SetType(mitk::LookupTable::INVERSE_GRAYSCALE);
       mitkLutProp->SetLookupTable(mitkLut);
       node->SetProperty("LookupTable", mitkLutProp);
     }
     // Otherwise do nothing - the default grayscale look-up table has already been set
   }
 
   bool isBinaryImage(false);
   if (!node->GetBoolProperty("binary", isBinaryImage))
   {
     // ok, property is not set, use heuristic to determine if this
     // is a binary image
     mitk::Image::Pointer centralSliceImage;
     ScalarType minValue = 0.0;
     ScalarType maxValue = 0.0;
     ScalarType min2ndValue = 0.0;
     ScalarType max2ndValue = 0.0;
     mitk::ImageSliceSelector::Pointer sliceSelector = mitk::ImageSliceSelector::New();
 
     sliceSelector->SetInput(image);
     sliceSelector->SetSliceNr(image->GetDimension(2) / 2);
     sliceSelector->SetTimeNr(image->GetDimension(3) / 2);
     sliceSelector->SetChannelNr(image->GetDimension(4) / 2);
     sliceSelector->Update();
     centralSliceImage = sliceSelector->GetOutput();
     if (centralSliceImage.IsNotNull() && centralSliceImage->IsInitialized())
     {
       minValue = centralSliceImage->GetStatistics()->GetScalarValueMin();
       maxValue = centralSliceImage->GetStatistics()->GetScalarValueMax();
       min2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMin();
       max2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMax();
     }
     if ((maxValue == min2ndValue && minValue == max2ndValue) || minValue == maxValue)
     {
       // centralSlice is strange, lets look at all data
       minValue = image->GetStatistics()->GetScalarValueMin();
       maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute();
       min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
       max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
     }
     isBinaryImage = (maxValue == min2ndValue && minValue == max2ndValue);
   }
 
   // some more properties specific for a binary...
   if (isBinaryImage)
   {
     node->AddProperty("opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite);
     node->AddProperty("color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
     node->AddProperty("binaryimage.selectedcolor", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
     node->AddProperty("binaryimage.selectedannotationcolor", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
     node->AddProperty("binaryimage.hoveringcolor", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
     node->AddProperty("binaryimage.hoveringannotationcolor", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
     node->AddProperty("binary", mitk::BoolProperty::New(true), renderer, overwrite);
     node->AddProperty("layer", mitk::IntProperty::New(10), renderer, overwrite);
   }
   else //...or image type object
   {
     node->AddProperty("opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite);
     node->AddProperty("color", ColorProperty::New(1.0, 1.0, 1.0), renderer, overwrite);
     node->AddProperty("binary", mitk::BoolProperty::New(false), renderer, overwrite);
     node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
 
     std::string className = image->GetNameOfClass();
 
     if (className != "TensorImage" && className != "OdfImage" && className != "ShImage")
     {
       PixelType pixelType = image->GetPixelType();
       size_t numComponents = pixelType.GetNumberOfComponents();
 
       if ((pixelType.GetPixelTypeAsString() == "vector" && numComponents > 1) || numComponents == 2 ||
           numComponents > 4)
         node->AddProperty("Image.Displayed Component", mitk::IntProperty::New(0), renderer, overwrite);
     }
   }
 
   if (image.IsNotNull() && image->IsInitialized())
   {
     if ((overwrite) || (node->GetProperty("levelwindow", renderer) == nullptr))
     {
       /* initialize level/window from DICOM tags */
       std::string sLevel;
       std::string sWindow;
 
       if (GetBackwardsCompatibleDICOMProperty(
             0x0028, 0x1050, "dicom.voilut.WindowCenter", image->GetPropertyList(), sLevel) &&
           GetBackwardsCompatibleDICOMProperty(
             0x0028, 0x1051, "dicom.voilut.WindowWidth", image->GetPropertyList(), sWindow))
       {
         float level = atof(sLevel.c_str());
         float window = atof(sWindow.c_str());
 
         mitk::LevelWindow contrast;
         std::string sSmallestPixelValueInSeries;
         std::string sLargestPixelValueInSeries;
 
         if (GetBackwardsCompatibleDICOMProperty(0x0028,
                                                 0x0108,
                                                 "dicom.series.SmallestPixelValueInSeries",
                                                 image->GetPropertyList(),
                                                 sSmallestPixelValueInSeries) &&
             GetBackwardsCompatibleDICOMProperty(0x0028,
                                                 0x0109,
                                                 "dicom.series.LargestPixelValueInSeries",
                                                 image->GetPropertyList(),
                                                 sLargestPixelValueInSeries))
         {
           float smallestPixelValueInSeries = atof(sSmallestPixelValueInSeries.c_str());
           float largestPixelValueInSeries = atof(sLargestPixelValueInSeries.c_str());
           contrast.SetRangeMinMax(smallestPixelValueInSeries - 1,
                                   largestPixelValueInSeries + 1); // why not a little buffer?
           // might remedy some l/w widget challenges
         }
         else
         {
           contrast.SetAuto(static_cast<mitk::Image *>(node->GetData()), false, true); // we need this as a fallback
         }
 
         contrast.SetLevelWindow(level, window, true);
         node->SetProperty("levelwindow", LevelWindowProperty::New(contrast), renderer);
       }
     }
     if (((overwrite) || (node->GetProperty("opaclevelwindow", renderer) == nullptr)) &&
         (image->GetPixelType().GetPixelType() == itk::IOPixelEnum::RGBA) &&
         (image->GetPixelType().GetComponentType() == itk::IOComponentEnum::UCHAR))
     {
       mitk::LevelWindow opaclevwin;
       opaclevwin.SetRangeMinMax(0, 255);
       opaclevwin.SetWindowBounds(0, 255);
       mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin);
       node->SetProperty("opaclevelwindow", prop, renderer);
     }
   }
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 mitk::DoseImageVtkMapper2D::LocalStorage *mitk::DoseImageVtkMapper2D::GetLocalStorage(mitk::BaseRenderer *renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 vtkSmartPointer<vtkPolyData> mitk::DoseImageVtkMapper2D::CreateOutlinePolyData(mitk::BaseRenderer *renderer)
 {
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();      // the points to draw
   vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New(); // the lines to connect the points
   vtkSmartPointer<vtkUnsignedCharArray> colors = vtkSmartPointer<vtkUnsignedCharArray>::New();
   colors->SetNumberOfComponents(3);
   colors->SetName("Colors");
 
   float pref;
   this->GetDataNode()->GetFloatProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), pref);
 
   mitk::IsoDoseLevelSetProperty::Pointer propIsoSet = dynamic_cast<mitk::IsoDoseLevelSetProperty *>(
     GetDataNode()->GetProperty(mitk::RTConstants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str()));
   mitk::IsoDoseLevelSet::Pointer isoDoseLevelSet = propIsoSet->GetValue();
 
   for (mitk::IsoDoseLevelSet::ConstIterator doseIT = isoDoseLevelSet->Begin(); doseIT != isoDoseLevelSet->End();
        ++doseIT)
   {
     if (doseIT->GetVisibleIsoLine())
     {
       this->CreateLevelOutline(renderer, &(doseIT.Value()), pref, points, lines, colors);
     } // end of if visible dose value
   }   // end of loop over all does values
 
   mitk::IsoDoseLevelVectorProperty::Pointer propfreeIsoVec = dynamic_cast<mitk::IsoDoseLevelVectorProperty *>(
     GetDataNode()->GetProperty(mitk::RTConstants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str()));
   mitk::IsoDoseLevelVector::Pointer frereIsoDoseLevelVec = propfreeIsoVec->GetValue();
 
   for (mitk::IsoDoseLevelVector::ConstIterator freeDoseIT = frereIsoDoseLevelVec->Begin();
        freeDoseIT != frereIsoDoseLevelVec->End();
        ++freeDoseIT)
   {
     if (freeDoseIT->Value()->GetVisibleIsoLine())
     {
       this->CreateLevelOutline(renderer, freeDoseIT->Value(), pref, points, lines, colors);
     } // end of if visible dose value
   }   // end of loop over all does values
 
   // Create a polydata to store everything in
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   // Add the points to the dataset
   polyData->SetPoints(points);
   // Add the lines to the dataset
   polyData->SetLines(lines);
   polyData->GetCellData()->SetScalars(colors);
   return polyData;
 }
 
 void mitk::DoseImageVtkMapper2D::CreateLevelOutline(mitk::BaseRenderer *renderer,
                                                     const mitk::IsoDoseLevel *level,
                                                     float pref,
                                                     vtkSmartPointer<vtkPoints> points,
                                                     vtkSmartPointer<vtkCellArray> lines,
                                                     vtkSmartPointer<vtkUnsignedCharArray> colors)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
 
   // get the min and max index values of each direction
   int *extent = localStorage->m_ReslicedImage->GetExtent();
   int xMin = extent[0];
   int xMax = extent[1];
   int yMin = extent[2];
   int yMax = extent[3];
 
   int *dims = localStorage->m_ReslicedImage->GetDimensions(); // dimensions of the image
   int line = dims[0];                                         // how many pixels per line?
   // get the depth for each contour
   float depth = CalculateLayerDepth(renderer);
 
   double doseValue = level->GetDoseValue() * pref;
   mitk::IsoDoseLevel::ColorType isoColor = level->GetColor();
   unsigned char colorLine[3] = {static_cast<unsigned char>(isoColor.GetRed() * 255),
                                 static_cast<unsigned char>(isoColor.GetGreen() * 255),
                                 static_cast<unsigned char>(isoColor.GetBlue() * 255)};
 
   int x = xMin; // pixel index x
   int y = yMin; // pixel index y
   float *currentPixel;
 
   // We take the pointer to the first pixel of the image
   currentPixel = static_cast<float *>(localStorage->m_ReslicedImage->GetScalarPointer());
 
   if (!currentPixel){
     mitkThrow() << "currentPixel invalid";
   }
 
   while (y <= yMax)
   {
     // if the current pixel value is set to something
     if ((currentPixel) && (*currentPixel >= doseValue))
     {
       // check in which direction a line is necessary
       // a line is added if the neighbor of the current pixel has the value 0
       // and if the pixel is located at the edge of the image
 
       // if   vvvvv  not the first line vvvvv
       if (y > yMin && *(currentPixel - line) < doseValue)
       { // x direction - bottom edge of the pixel
         // add the 2 points
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         // add the line between both points
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
         colors->InsertNextTypedTuple(colorLine);
       }
 
       // if   vvvvv  not the last line vvvvv
       if (y < yMax && *(currentPixel + line) < doseValue)
       { // x direction - top edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
         colors->InsertNextTypedTuple(colorLine);
       }
 
       // if   vvvvv  not the first pixel vvvvv
       if ((x > xMin || y > yMin) && *(currentPixel - 1) < doseValue)
       { // y direction - left edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
         colors->InsertNextTypedTuple(colorLine);
       }
 
       // if   vvvvv  not the last pixel vvvvv
       if ((y < yMax || (x < xMax)) && *(currentPixel + 1) < doseValue)
       { // y direction - right edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
         colors->InsertNextTypedTuple(colorLine);
       }
 
       /*  now consider pixels at the edge of the image  */
 
       // if   vvvvv  left edge of image vvvvv
       if (x == xMin)
       { // draw left edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
         colors->InsertNextTypedTuple(colorLine);
       }
 
       // if   vvvvv  right edge of image vvvvv
       if (x == xMax)
       { // draw right edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
         colors->InsertNextTypedTuple(colorLine);
       }
 
       // if   vvvvv  bottom edge of image vvvvv
       if (y == yMin)
       { // draw bottom edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
         colors->InsertNextTypedTuple(colorLine);
       }
 
       // if   vvvvv  top edge of image vvvvv
       if (y == yMax)
       { // draw top edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
         colors->InsertNextTypedTuple(colorLine);
       }
     } // end if currentpixel is set
 
     x++;
 
     if (x > xMax)
     { // reached end of line
       x = xMin;
       y++;
     }
 
     // Increase the pointer-position to the next pixel.
     // This is safe, as the while-loop and the x-reset logic above makes
     // sure we do not exceed the bounds of the image
     currentPixel++;
   } // end of while
 }
 
 void mitk::DoseImageVtkMapper2D::TransformActor(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
-  // get the transformation matrix of the reslicer in order to render the slice as axial, coronal or saggital
+  // get the transformation matrix of the reslicer in order to render the slice as axial, coronal or sagittal
   vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
   vtkSmartPointer<vtkMatrix4x4> matrix = localStorage->m_Reslicer->GetResliceAxes();
   trans->SetMatrix(matrix);
-  // transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or saggital)
+  // transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or sagittal)
   localStorage->m_Actor->SetUserTransform(trans);
   // transform the origin to center based coordinates, because MITK is center based.
   localStorage->m_Actor->SetPosition(-0.5 * localStorage->m_mmPerPixel[0], -0.5 * localStorage->m_mmPerPixel[1], 0.0);
 
   if (localStorage->m_Actors->GetNumberOfPaths() > 1)
   {
     vtkActor *secondaryActor = dynamic_cast<vtkActor *>(localStorage->m_Actors->GetParts()->GetItemAsObject(0));
     secondaryActor->SetUserTransform(trans);
     secondaryActor->SetPosition(-0.5 * localStorage->m_mmPerPixel[0], -0.5 * localStorage->m_mmPerPixel[1], 0.0);
   }
 }
 
 bool mitk::DoseImageVtkMapper2D::RenderingGeometryIntersectsImage(const PlaneGeometry *renderingGeometry,
                                                                   SlicedGeometry3D *imageGeometry)
 {
   // if either one of the two geometries is nullptr we return true
   // for safety reasons
   if (renderingGeometry == nullptr || imageGeometry == nullptr)
     return true;
 
   // get the distance for the first cornerpoint
   ScalarType initialDistance = renderingGeometry->SignedDistance(imageGeometry->GetCornerPoint(0));
   for (int i = 1; i < 8; i++)
   {
     mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint(i);
 
     // get the distance to the other cornerpoints
     ScalarType distance = renderingGeometry->SignedDistance(cornerPoint);
 
     // if it has not the same signing as the distance of the first point
     if (initialDistance * distance < 0)
     {
       // we have an intersection and return true
       return true;
     }
   }
 
   // all distances have the same sign, no intersection and we return false
   return false;
 }
 
 mitk::DoseImageVtkMapper2D::LocalStorage::~LocalStorage()
 {
 }
 
 mitk::DoseImageVtkMapper2D::LocalStorage::LocalStorage()
   : m_VectorComponentExtractor(vtkSmartPointer<vtkImageExtractComponents>::New())
 {
   m_LevelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
 
   // Do as much actions as possible in here to avoid double executions.
   m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
   m_Texture = vtkSmartPointer<vtkNeverTranslucentTexture>::New().GetPointer();
   m_DefaultLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_BinaryLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_ColorLookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_Actor = vtkSmartPointer<vtkActor>::New();
   m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
   m_Reslicer = mitk::ExtractSliceFilter::New();
   m_TSFilter = vtkSmartPointer<vtkMitkThickSlicesFilter>::New();
   m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
   m_ReslicedImage = vtkSmartPointer<vtkImageData>::New();
   m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
 
   // the following actions are always the same and thus can be performed
   // in the constructor for each image (i.e. the image-corresponding local storage)
   m_TSFilter->ReleaseDataFlagOn();
 
   mitk::LookupTable::Pointer mitkLUT = mitk::LookupTable::New();
   // built a default lookuptable
   mitkLUT->SetType(mitk::LookupTable::GRAYSCALE);
   m_DefaultLookupTable = mitkLUT->GetVtkLookupTable();
 
   mitkLUT->SetType(mitk::LookupTable::LEGACY_BINARY);
   m_BinaryLookupTable = mitkLUT->GetVtkLookupTable();
 
   mitkLUT->SetType(mitk::LookupTable::LEGACY_RAINBOW_COLOR);
   m_ColorLookupTable = mitkLUT->GetVtkLookupTable();
 
   // do not repeat the texture (the image)
   m_Texture->RepeatOff();
 
   // set the mapper for the actor
   m_Actor->SetMapper(m_Mapper);
 
   vtkSmartPointer<vtkActor> outlineShadowActor = vtkSmartPointer<vtkActor>::New();
   outlineShadowActor->SetMapper(m_Mapper);
 
   m_Actors->AddPart(outlineShadowActor);
   m_Actors->AddPart(m_Actor);
 }
diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h b/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h
index 87825914a2..2224b41fe4 100644
--- a/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h
+++ b/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h
@@ -1,82 +1,82 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #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'
+  * The view direction can be changed to 'mitk::SliceNavigationController::Axial', 'mitk::SliceNavigationController::Coronal'
   * 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);
     /**
     * @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/mitkRenderWindowViewDirectionController.cpp b/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp
index fa905dc45f..6923c4ea9c 100644
--- a/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp
+++ b/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp
@@ -1,137 +1,137 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "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*/)
 {
   if (nullptr == renderer)
   {
     // set visibility of data node in all controlled renderer
     for (auto& renderer : m_ControlledRenderer)
     {
       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);
+      sliceNavigationController->SetDefaultViewDirection(ViewDirection::Coronal);
     }
     else if ("sagittal" == viewDirection)
     {
       sliceNavigationController->SetDefaultViewDirection(ViewDirection::Sagittal);
     }
 
     if ("3D" == viewDirection)
     {
       renderer->SetMapperID(mitk::BaseRenderer::Standard3D);
     }
     else
     {
       renderer->SetMapperID(mitk::BaseRenderer::Standard2D);
 
     }
     // 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 (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/Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageListModel.h b/Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageListModel.h
index 50b705f279..3e392fdf9b 100644
--- a/Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageListModel.h
+++ b/Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageListModel.h
@@ -1,104 +1,104 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKDATASTORAGERENDERWINDOWLISTMODEL_H
 #define QMITKDATASTORAGERENDERWINDOWLISTMODEL_H
 
 // render window manager UI model
 #include "MitkRenderWindowManagerUIExports.h"
 
 // render window manager module
 #include "mitkRenderWindowLayerController.h"
 #include "mitkRenderWindowLayerUtilities.h"
 
 //mitk core
 #include <mitkBaseRenderer.h>
 
 // qt widgets module
 #include <QmitkAbstractDataStorageModel.h>
 
 /*
 * @brief The 'QmitkDataStorageRenderWindowListModel' is a list model derived from the 'QmitkAbstractDataStorageModel'.
 */
 class MITKRENDERWINDOWMANAGERUI_EXPORT QmitkRenderWindowDataStorageListModel : public QmitkAbstractDataStorageModel
 {
   Q_OBJECT
 
 public:
 
   QmitkRenderWindowDataStorageListModel(QObject* parent = nullptr);
 
   // override from 'QmitkAbstractDataStorageModel'
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void DataStorageChanged() override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodePredicateChanged() override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeAdded(const mitk::DataNode* node) override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeChanged(const mitk::DataNode* node) override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeRemoved(const mitk::DataNode* node) override;
 
   // override from 'QAbstractItemModel'
   QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
   QModelIndex parent(const QModelIndex& child) const override;
 
   int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   int columnCount(const QModelIndex& parent = QModelIndex()) const override;
 
   QVariant data(const QModelIndex& index, int role) const override;
   bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
 
   Qt::ItemFlags flags(const QModelIndex& index) const override;
 
   Qt::DropActions supportedDropActions() const override;
   Qt::DropActions supportedDragActions() const override;
   QStringList mimeTypes() const override;
   QMimeData* mimeData(const QModelIndexList& indexes) const override;
 
   bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override;
 
   void SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer);
 
   void SetCurrentRenderer(mitk::BaseRenderer* baseRenderer);
-  mitk::BaseRenderer* GetCurrentRenderer() const;
+  mitk::BaseRenderer::Pointer GetCurrentRenderer() const;
 
   /**
   * @brief Use the RenderWindowLayerController to insert the given data node into all controlled render windows.
   *        The new node is placed on top of all existing layer nodes in the render window.
   *
   * @param dataNode   The data node that should be inserted.
   */
   void AddDataNodeToAllRenderer(mitk::DataNode* dataNode);
 
 private:
 
   void UpdateModelData();
 
   std::unique_ptr<mitk::RenderWindowLayerController> m_RenderWindowLayerController;
   mitk::WeakPointer<mitk::BaseRenderer> m_BaseRenderer;
   mitk::RenderWindowLayerUtilities::LayerStack m_LayerStack;
 
 };
 
 #endif // QMITKDATASTORAGERENDERWINDOWLISTMODEL_H
diff --git a/Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageTreeModel.h b/Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageTreeModel.h
index d1ce14312b..776e38304a 100644
--- a/Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageTreeModel.h
+++ b/Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageTreeModel.h
@@ -1,132 +1,132 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKDATASTORAGERENDERWINDOWTREEMODEL_H
 #define QMITKDATASTORAGERENDERWINDOWTREEMODEL_H
 
 // render window manager UI model
 #include "MitkRenderWindowManagerUIExports.h"
 
 // render window manager module
 #include "mitkRenderWindowLayerController.h"
 #include "mitkRenderWindowLayerUtilities.h"
 
 //mitk core
 #include <mitkBaseRenderer.h>
 
 // qt widgets module
 #include <QmitkAbstractDataStorageModel.h>
 #include <QmitkDataStorageTreeModelInternalItem.h>
 
 /*
 * @brief The 'QmitkRenderWindowDataStorageTreeModel' is a tree model derived from the 'QmitkAbstractDataStorageModel'.
 */
 class MITKRENDERWINDOWMANAGERUI_EXPORT QmitkRenderWindowDataStorageTreeModel : public QmitkAbstractDataStorageModel
 {
   Q_OBJECT
 
 public:
 
   QmitkRenderWindowDataStorageTreeModel(QObject* parent = nullptr);
 
   // override from 'QmitkAbstractDataStorageModel'
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void DataStorageChanged() override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodePredicateChanged() override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeAdded(const mitk::DataNode* node) override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeChanged(const mitk::DataNode* node) override;
   /**
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeRemoved(const mitk::DataNode* node) override;
 
   // override from 'QAbstractItemModel'
   QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
   QModelIndex parent(const QModelIndex& parent) const override;
 
   int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   int columnCount(const QModelIndex& parent = QModelIndex()) const override;
 
   QVariant data(const QModelIndex& index, int role) const override;
   bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
 
   Qt::ItemFlags flags(const QModelIndex& index) const override;
 
   Qt::DropActions supportedDropActions() const override;
   Qt::DropActions supportedDragActions() const override;
   QStringList mimeTypes() const override;
   QMimeData* mimeData(const QModelIndexList& indexes) const override;
 
   bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override;
 
   void SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer);
 
   void SetCurrentRenderer(mitk::BaseRenderer* baseRenderer);
-  mitk::BaseRenderer* GetCurrentRenderer() const;
+  mitk::BaseRenderer::Pointer GetCurrentRenderer() const;
 
 private:
 
   void ResetTree();
   void UpdateModelData();
   /**
   * @brief Adjust the layer property according to the current tree.
   *        The function will set the "layer" property of each underlying data node so that it fits the
   *        the actual hierarchy represented by the current tree.
   */
   void AdjustLayerProperty();
   /**
   * @brief Fill a vector of tree items in a depth-first order (child-first).
   */
   void TreeToVector(QmitkDataStorageTreeModelInternalItem* parent, std::vector<QmitkDataStorageTreeModelInternalItem*>& treeAsVector) const;
   /**
   * @brief Add the given data node to the tree of the given renderer.
   *        The given renderer specifies the "layer"-property that is used for adding the new tree item
   *        to the tree. The "layer"-property may be different for each renderer resulting in a
   *        different tree for each renderer.
   *
   * @param dataNode   The data node that should be added.
   * @param renderer   The base renderer to which the data node should be added.
   */
   void AddNodeInternal(const mitk::DataNode* dataNode, const mitk::BaseRenderer* renderer);
   /**
   * @brief Remove the tree item that contains the given data node. Removing an item may
   *        leave the child items of the removed item without a parent. In this case
   *        the children have to be moved inside the tree so the tree has to be rebuild
   *        according to the current status of the data storage.
   *
   * @param dataNode   The data node that should be removed.
   */
   void RemoveNodeInternal(const mitk::DataNode* dataNode);
 
   mitk::DataNode* GetParentNode(const mitk::DataNode* node) const;
   QmitkDataStorageTreeModelInternalItem* GetItemByIndex(const QModelIndex& index) const;
   QModelIndex GetIndexByItem(QmitkDataStorageTreeModelInternalItem* item) const;
 
   std::unique_ptr<mitk::RenderWindowLayerController> m_RenderWindowLayerController;
   mitk::RenderWindowLayerUtilities::RendererVector m_ControlledRenderer;
   QmitkDataStorageTreeModelInternalItem* m_Root;
   mitk::WeakPointer<mitk::BaseRenderer> m_BaseRenderer;
 
 };
 
 #endif // QMITKDATASTORAGERENDERWINDOWTREEMODEL_H
diff --git a/Modules/RenderWindowManagerUI/src/QmitkDataStorageLayerStackModel.cpp b/Modules/RenderWindowManagerUI/src/QmitkDataStorageLayerStackModel.cpp
index 35f6733688..59232e7a5a 100644
--- a/Modules/RenderWindowManagerUI/src/QmitkDataStorageLayerStackModel.cpp
+++ b/Modules/RenderWindowManagerUI/src/QmitkDataStorageLayerStackModel.cpp
@@ -1,234 +1,234 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkDataStorageLayerStackModel.h>
 
 // qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 
 QmitkDataStorageLayerStackModel::QmitkDataStorageLayerStackModel(QObject* parent/* = nullptr*/)
   : QmitkAbstractDataStorageModel(parent)
 {
   // nothing here
 }
 
 void QmitkDataStorageLayerStackModel::DataStorageChanged()
 {
   UpdateModelData();
 }
 
 void QmitkDataStorageLayerStackModel::NodePredicateChanged()
 {
   UpdateModelData();
 }
 
 void QmitkDataStorageLayerStackModel::NodeAdded(const mitk::DataNode* /*node*/)
 {
   // nothing here; layers (nodes) are only added after button click
 }
 
 void QmitkDataStorageLayerStackModel::NodeChanged(const mitk::DataNode* /*node*/)
 {
   UpdateModelData();
 }
 
 void QmitkDataStorageLayerStackModel::NodeRemoved(const mitk::DataNode* /*node*/)
 {
   UpdateModelData();
 }
 
 void QmitkDataStorageLayerStackModel::SetCurrentRenderer(const std::string& renderWindowName)
 {
   if (!m_DataStorage.IsExpired())
   {
     m_BaseRenderer = mitk::BaseRenderer::GetByName(renderWindowName);
     UpdateModelData();
   }
 }
 
 mitk::BaseRenderer* QmitkDataStorageLayerStackModel::GetCurrentRenderer() const
 {
   return m_BaseRenderer.Lock();
 }
 
 QModelIndex QmitkDataStorageLayerStackModel::index(int row, int column, const QModelIndex& parent) const
 {
   bool hasIndex = this->hasIndex(row, column, parent);
   if (hasIndex)
   {
     return this->createIndex(row, column);
   }
 
   return QModelIndex();
 }
 
 QModelIndex QmitkDataStorageLayerStackModel::parent(const QModelIndex& /*child*/) const
 {
   return QModelIndex();
 }
 
 Qt::ItemFlags QmitkDataStorageLayerStackModel::flags(const QModelIndex& index) const
 {
   Qt::ItemFlags flags = Qt::NoItemFlags;
   if (index.isValid() && index.model() == this)
   {
     flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
     if (0 == index.column())
     {
       flags |= Qt::ItemIsUserCheckable;
     }
   }
 
   return flags;
 }
 
 QVariant QmitkDataStorageLayerStackModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (Qt::Horizontal == orientation && Qt::DisplayRole == role)
   {
     if (0 == section)
     {
       return QVariant("Visibility");
     }
     else if (1 == section)
     {
       return QVariant("Data node");
     }
   }
   return QVariant();
 }
 
 int QmitkDataStorageLayerStackModel::rowCount(const QModelIndex& parent/* = QModelIndex()*/) const
 {
   if (parent.isValid())
   {
     return 0;
   }
 
   return static_cast<int>(m_TempLayerStack.size());
 }
 
 int QmitkDataStorageLayerStackModel::columnCount(const QModelIndex& parent/* = QModelIndex()*/) const
 {
   if (parent.isValid())
   {
     return 0;
   }
 
   return 2;
 }
 
 QVariant QmitkDataStorageLayerStackModel::data(const QModelIndex& index, int role) const
 {
   if (!index.isValid() || index.model() != this)
   {
     return QVariant();
   }
 
   if ((index.row()) < 0 || index.row() >= static_cast<int>(m_TempLayerStack.size()))
   {
     return QVariant();
   }
 
   RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIt = m_TempLayerStack.begin();
   std::advance(layerStackIt, index.row());
   mitk::DataNode* dataNode = layerStackIt->second;
   if (Qt::CheckStateRole == role && 0 == index.column())
   {
     bool visibility = false;
     dataNode->GetVisibility(visibility, m_BaseRenderer.Lock());
     if (visibility)
     {
       return Qt::Checked;
     }
     else
     {
       return Qt::Unchecked;
     }
   }
   else if (Qt::DisplayRole == role && 1 == index.column())
   {
     return QVariant(QString::fromStdString(dataNode->GetName()));
   }
   else if (Qt::ToolTipRole == role)
   {
     if (0 == index.column())
     {
       return QVariant("Show/hide data node.");
     }
     else if (1 == index.column())
     {
       return QVariant("Name of the data node.");
     }
   }
   else if (QmitkDataNodeRole == role)
   {
     return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
   }
   else if (QmitkDataNodeRawPointerRole == role)
   {
     return QVariant::fromValue<mitk::DataNode*>(dataNode);
   }
 
   return QVariant();
 }
 
 bool QmitkDataStorageLayerStackModel::setData(const QModelIndex &index, const QVariant &value, int role /*= Qt::EditRole*/)
 {
   if (!index.isValid() || index.model() != this)
   {
     return false;
   }
 
   if ((index.row()) < 0 || index.row() >= static_cast<int>(m_TempLayerStack.size()))
   {
     return false;
   }
 
-  if (!m_BaseRenderer.IsExpired())
-  {
-    auto baseRenderer = m_BaseRenderer.Lock();
+  auto baseRenderer = m_BaseRenderer.Lock();
 
+  if (baseRenderer.IsNotNull())
+  {
     RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIt = m_TempLayerStack.begin();
     std::advance(layerStackIt, index.row());
     mitk::DataNode* dataNode = layerStackIt->second;
     if (Qt::CheckStateRole == role)
     {
       Qt::CheckState newCheckState = static_cast<Qt::CheckState>(value.toInt());
 
       if (Qt::PartiallyChecked == newCheckState || Qt::Checked == newCheckState)
       {
         dataNode->SetVisibility(true, baseRenderer);
       }
       else
       {
         dataNode->SetVisibility(false, baseRenderer);
       }
       emit dataChanged(index, index);
       mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
       return true;
     }
   }
 
   return false;
 }
 
 void QmitkDataStorageLayerStackModel::UpdateModelData()
 {
   // update the model, so that the table will be filled with the nodes according to the current
   // data storage and base renderer
   beginResetModel();
   // get the current layer stack of the given base renderer
   m_TempLayerStack = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage.Lock(), m_BaseRenderer.Lock(), true);
   endResetModel();
 }
diff --git a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageInspector.cpp b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageInspector.cpp
index 29fdf72bb8..b06b5ca790 100644
--- a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageInspector.cpp
+++ b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageInspector.cpp
@@ -1,169 +1,167 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // render window manager UI module
 #include "QmitkRenderWindowDataStorageInspector.h"
 
 #include "QmitkCustomVariants.h"
 
 // mitk core
 #include <mitkBaseRenderer.h>
 
 // qt
 #include <QSignalMapper>
 
 QmitkRenderWindowDataStorageInspector::QmitkRenderWindowDataStorageInspector(QWidget* parent /*=nullptr*/)
   : QmitkAbstractDataStorageInspector(parent)
 {
   m_Controls.setupUi(this);
 
   // initialize the render window layer controller and the render window view direction controller
   m_RenderWindowLayerController = std::make_unique<mitk::RenderWindowLayerController>();
   m_RenderWindowViewDirectionController = std::make_unique<mitk::RenderWindowViewDirectionController>();
 
   m_StorageModel = std::make_unique<QmitkRenderWindowDataStorageTreeModel>(this);
 
   m_Controls.renderWindowTreeView->setModel(m_StorageModel.get());
   m_Controls.renderWindowTreeView->setHeaderHidden(true);
   m_Controls.renderWindowTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
   m_Controls.renderWindowTreeView->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_Controls.renderWindowTreeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
   m_Controls.renderWindowTreeView->setAlternatingRowColors(true);
   m_Controls.renderWindowTreeView->setDragEnabled(true);
   m_Controls.renderWindowTreeView->setDropIndicatorShown(true);
   m_Controls.renderWindowTreeView->setAcceptDrops(true);
   m_Controls.renderWindowTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   SetUpConnections();
 }
 
 QAbstractItemView* QmitkRenderWindowDataStorageInspector::GetView()
 {
   return m_Controls.renderWindowTreeView;
 }
 
 const QAbstractItemView* QmitkRenderWindowDataStorageInspector::GetView() const
 {
   return m_Controls.renderWindowTreeView;
 }
 
 void QmitkRenderWindowDataStorageInspector::SetSelectionMode(SelectionMode mode)
 {
   m_Controls.renderWindowTreeView->setSelectionMode(mode);
 }
 
 QmitkRenderWindowDataStorageInspector::SelectionMode QmitkRenderWindowDataStorageInspector::GetSelectionMode() const
 {
   return m_Controls.renderWindowTreeView->selectionMode();
 }
 
 void QmitkRenderWindowDataStorageInspector::Initialize()
 {
-  if (m_DataStorage.IsExpired())
-  {
-    return;
-  }
-
   auto dataStorage = m_DataStorage.Lock();
 
+  if (dataStorage.IsNull())
+    return;
+
   m_StorageModel->SetDataStorage(dataStorage);
   m_StorageModel->SetNodePredicate(m_NodePredicate);
 
   m_RenderWindowLayerController->SetDataStorage(dataStorage);
   m_RenderWindowViewDirectionController->SetDataStorage(dataStorage);
 
   m_Connector->SetView(m_Controls.renderWindowTreeView);
 }
 
 void QmitkRenderWindowDataStorageInspector::SetUpConnections()
 {
   connect(m_StorageModel.get(), &QAbstractItemModel::rowsInserted, this, &QmitkRenderWindowDataStorageInspector::ModelRowsInserted);
 
   connect(m_Controls.pushButtonSetAsBaseLayer, &QPushButton::clicked, this, &QmitkRenderWindowDataStorageInspector::SetAsBaseLayer);
   connect(m_Controls.pushButtonResetRenderer, &QPushButton::clicked, this, &QmitkRenderWindowDataStorageInspector::ResetRenderer);
 
   QSignalMapper* changeViewDirectionSignalMapper = new QSignalMapper(this);
   changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonAxial, QString("axial"));
   changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonCoronal, QString("coronal"));
   changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonSagittal, QString("sagittal"));
   changeViewDirectionSignalMapper->setMapping(m_Controls.radioButton3D, QString("3D"));
   connect(changeViewDirectionSignalMapper, static_cast<void(QSignalMapper::*)(const QString&)>(&QSignalMapper::mapped), this, &QmitkRenderWindowDataStorageInspector::ChangeViewDirection);
 
   connect(m_Controls.radioButtonAxial, &QPushButton::clicked, changeViewDirectionSignalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
   connect(m_Controls.radioButtonCoronal, &QPushButton::clicked, changeViewDirectionSignalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
   connect(m_Controls.radioButtonSagittal, &QPushButton::clicked, changeViewDirectionSignalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
   connect(m_Controls.radioButton3D, &QPushButton::clicked, changeViewDirectionSignalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
 }
 
 void QmitkRenderWindowDataStorageInspector::SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer)
 {
   m_StorageModel->SetControlledRenderer(controlledRenderer);
   m_RenderWindowLayerController->SetControlledRenderer(controlledRenderer);
   m_RenderWindowViewDirectionController->SetControlledRenderer(controlledRenderer);
 }
 
 void QmitkRenderWindowDataStorageInspector::SetActiveRenderWindow(const QString& renderWindowId)
 {
   mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(renderWindowId.toStdString());
   if (nullptr == selectedRenderer)
   {
     return;
   }
 
   m_StorageModel->SetCurrentRenderer(selectedRenderer);
   mitk::SliceNavigationController::ViewDirection viewDirection = selectedRenderer->GetSliceNavigationController()->GetDefaultViewDirection();
   switch (viewDirection)
   {
   case mitk::SliceNavigationController::Axial:
     m_Controls.radioButtonAxial->setChecked(true);
     break;
-  case mitk::SliceNavigationController::Frontal:
+  case mitk::SliceNavigationController::Coronal:
     m_Controls.radioButtonCoronal->setChecked(true);
     break;
   case mitk::SliceNavigationController::Sagittal:
     m_Controls.radioButtonSagittal->setChecked(true);
     break;
   default:
     break;
   }
 }
 
 void QmitkRenderWindowDataStorageInspector::ModelRowsInserted(const QModelIndex& parent, int /*start*/, int /*end*/)
 {
   m_Controls.renderWindowTreeView->setExpanded(parent, true);
 }
 
 void QmitkRenderWindowDataStorageInspector::SetAsBaseLayer()
 {
   QModelIndex selectedIndex = m_Controls.renderWindowTreeView->currentIndex();
   if (selectedIndex.isValid())
   {
     QVariant qvariantDataNode = m_StorageModel->data(selectedIndex, Qt::UserRole);
     if (qvariantDataNode.canConvert<mitk::DataNode*>())
     {
       mitk::DataNode* dataNode = qvariantDataNode.value<mitk::DataNode*>();
       m_RenderWindowLayerController->SetBaseDataNode(dataNode, m_StorageModel->GetCurrentRenderer());
       m_Controls.renderWindowTreeView->clearSelection();
     }
   }
 }
 
 void QmitkRenderWindowDataStorageInspector::ResetRenderer()
 {
   m_RenderWindowLayerController->ResetRenderer(true, m_StorageModel->GetCurrentRenderer());
   m_Controls.renderWindowTreeView->clearSelection();
 }
 
 void QmitkRenderWindowDataStorageInspector::ChangeViewDirection(const QString& viewDirection)
 {
   m_RenderWindowViewDirectionController->SetViewDirectionOfRenderer(viewDirection.toStdString(), m_StorageModel->GetCurrentRenderer());
 }
diff --git a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageListModel.cpp b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageListModel.cpp
index 67c0c79336..9b6face241 100644
--- a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageListModel.cpp
+++ b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageListModel.cpp
@@ -1,354 +1,351 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // render window manager UI module
 #include "QmitkRenderWindowDataStorageListModel.h"
 
 // qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 #include "QmitkMimeTypes.h"
 #include "QmitkNodeDescriptorManager.h"
 
 QmitkRenderWindowDataStorageListModel::QmitkRenderWindowDataStorageListModel(QObject* parent /*= nullptr*/)
   : QmitkAbstractDataStorageModel(parent)
 {
   m_RenderWindowLayerController = std::make_unique<mitk::RenderWindowLayerController>();
 }
 
 void QmitkRenderWindowDataStorageListModel::DataStorageChanged()
 {
   m_RenderWindowLayerController->SetDataStorage(m_DataStorage.Lock());
   UpdateModelData();
 }
 
 void QmitkRenderWindowDataStorageListModel::NodePredicateChanged()
 {
   UpdateModelData();
 }
 
 void QmitkRenderWindowDataStorageListModel::NodeAdded(const mitk::DataNode* node)
 {
   // add a node to each render window specific list (or to a global list initially)
   AddDataNodeToAllRenderer(const_cast<mitk::DataNode*>(node));
   UpdateModelData();
 }
 
 void QmitkRenderWindowDataStorageListModel::NodeChanged(const mitk::DataNode* /*node*/)
 {
   // nothing here, since the "'NodeChanged'-event is currently sent far too often
 }
 
 void QmitkRenderWindowDataStorageListModel::NodeRemoved(const mitk::DataNode* /*node*/)
 {
   // update model data to create a new list without the removed data node
   UpdateModelData();
 }
 
 QModelIndex QmitkRenderWindowDataStorageListModel::index(int row, int column, const QModelIndex& parent) const
 {
   bool hasIndex = this->hasIndex(row, column, parent);
   if (hasIndex)
   {
     return this->createIndex(row, column);
   }
 
   return QModelIndex();
 }
 
 QModelIndex QmitkRenderWindowDataStorageListModel::parent(const QModelIndex& /*child*/) const
 {
   return QModelIndex();
 }
 
 int QmitkRenderWindowDataStorageListModel::rowCount(const QModelIndex& parent /*= QModelIndex()*/) const
 {
   if (parent.isValid())
   {
     return 0;
   }
 
   return static_cast<int>(m_LayerStack.size());
 }
 
 int QmitkRenderWindowDataStorageListModel::columnCount(const QModelIndex& parent /*= QModelIndex()*/) const
 {
   if (parent.isValid())
   {
     return 0;
   }
 
   return 1;
 }
 
 QVariant QmitkRenderWindowDataStorageListModel::data(const QModelIndex& index, int role) const
 {
-  if (m_BaseRenderer.IsExpired())
+  auto baseRenderer = m_BaseRenderer.Lock();
+
+  if (baseRenderer.IsNull())
   {
     return QVariant();
   }
 
-  auto baseRenderer = m_BaseRenderer.Lock();
-
   if (!index.isValid() || this != index.model())
   {
     return QVariant();
   }
 
   if (index.row() < 0 || index.row() >= static_cast<int>(m_LayerStack.size()))
   {
     return QVariant();
   }
 
   mitk::RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIt = m_LayerStack.begin();
   std::advance(layerStackIt, index.row());
   mitk::DataNode* dataNode = layerStackIt->second;
 
   if (Qt::CheckStateRole == role)
   {
     bool visibility = false;
     dataNode->GetVisibility(visibility, baseRenderer);
     if (visibility)
     {
       return Qt::Checked;
     }
     else
     {
       return Qt::Unchecked;
     }
   }
   else if (Qt::DisplayRole == role)
   {
     return QVariant(QString::fromStdString(dataNode->GetName()));
   }
   else if (Qt::ToolTipRole == role)
   {
     return QVariant("Name of the data node.");
   }
   else if (Qt::DecorationRole == role)
   {
     QmitkNodeDescriptor* nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
     return nodeDescriptor->GetIcon(dataNode);
   }
   else if (Qt::UserRole == role || QmitkDataNodeRawPointerRole == role)
   {
     // user role always returns a reference to the data node,
     // which can be used to modify the data node in the data storage
     return QVariant::fromValue<mitk::DataNode*>(dataNode);
   }
   else if (QmitkDataNodeRole == role)
   {
     return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
   }
 
   return QVariant();
 }
 
 bool QmitkRenderWindowDataStorageListModel::setData(const QModelIndex& index, const QVariant& value, int role /*= Qt::EditRole*/)
 {
-  if (m_BaseRenderer.IsExpired())
+  auto baseRenderer = m_BaseRenderer.Lock();
+
+  if (baseRenderer.IsNull())
   {
     return false;
   }
 
-  auto baseRenderer = m_BaseRenderer.Lock();
-
   if (!index.isValid() || this != index.model())
   {
     return false;
   }
 
   if (index.row() < 0 || index.row() >= static_cast<int>(m_LayerStack.size()))
   {
     return false;
   }
 
   mitk::RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIt = m_LayerStack.begin();
   std::advance(layerStackIt, index.row());
   mitk::DataNode* dataNode = layerStackIt->second;
   if (Qt::CheckStateRole == role)
   {
     Qt::CheckState newCheckState = static_cast<Qt::CheckState>(value.toInt());
     bool isVisible = newCheckState;
     dataNode->SetVisibility(isVisible, baseRenderer);
 
     emit dataChanged(index, index);
     mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
     return true;
   }
   return false;
 }
 
 Qt::ItemFlags QmitkRenderWindowDataStorageListModel::flags(const QModelIndex &index) const
 {
   if (this != index.model())
   {
     return Qt::NoItemFlags;
   }
 
   if (!index.isValid())
   {
     return Qt::ItemIsDropEnabled;
   }
 
   return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
 }
 
 Qt::DropActions QmitkRenderWindowDataStorageListModel::supportedDropActions() const
 {
   return Qt::CopyAction | Qt::MoveAction;
 }
 
 Qt::DropActions QmitkRenderWindowDataStorageListModel::supportedDragActions() const
 {
   return Qt::CopyAction | Qt::MoveAction;
 }
 
 QStringList QmitkRenderWindowDataStorageListModel::mimeTypes() const
 {
   QStringList types = QAbstractItemModel::mimeTypes();
   types << QmitkMimeTypes::DataNodePtrs;
   return types;
 }
 
 QMimeData* QmitkRenderWindowDataStorageListModel::mimeData(const QModelIndexList& indexes) const
 {
   QMimeData* mimeData = new QMimeData();
   QByteArray encodedData;
 
   QDataStream stream(&encodedData, QIODevice::WriteOnly);
 
   for (const auto& index : indexes)
   {
     if (index.isValid())
     {
       auto dataNode = data(index, QmitkDataNodeRawPointerRole).value<mitk::DataNode*>();
       stream << reinterpret_cast<quintptr>(dataNode);
     }
   }
 
   mimeData->setData(QmitkMimeTypes::DataNodePtrs, encodedData);
   return mimeData;
 }
 
 bool QmitkRenderWindowDataStorageListModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int /*row*/, int column, const QModelIndex& parent)
 {
-  if (m_BaseRenderer.IsExpired())
+  auto baseRenderer = m_BaseRenderer.Lock();
+
+  if (baseRenderer.IsNull())
   {
     return false;
   }
 
-  auto baseRenderer = m_BaseRenderer.Lock();
-
   if (action == Qt::IgnoreAction)
   {
     return true;
   }
 
   if (!data->hasFormat(QmitkMimeTypes::DataNodePtrs))
   {
     return false;
   }
 
   if (column > 0)
   {
     return false;
   }
 
   if (parent.isValid())
   {
     int layer = -1;
     auto dataNode = this->data(parent, QmitkDataNodeRawPointerRole).value<mitk::DataNode*>();
     if (nullptr != dataNode)
     {
       dataNode->GetIntProperty("layer", layer, baseRenderer);
     }
 
     auto dataNodeList = QmitkMimeTypes::ToDataNodePtrList(data);
     for (const auto& dataNode : qAsConst(dataNodeList))
     {
       m_RenderWindowLayerController->MoveNodeToPosition(dataNode, layer, baseRenderer);
     }
 
     UpdateModelData();
     return true;
   }
 
   return false;
 }
 
 void QmitkRenderWindowDataStorageListModel::SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer)
 {
   m_RenderWindowLayerController->SetControlledRenderer(controlledRenderer);
+  auto dataStorage = m_DataStorage.Lock();
 
-  if (!m_DataStorage.IsExpired())
+  if (dataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
     mitk::DataStorage::SetOfObjects::ConstPointer allDataNodes = dataStorage->GetAll();
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = allDataNodes->Begin(); it != allDataNodes->End(); ++it)
     {
       mitk::DataNode::Pointer dataNode = it->Value();
       if (dataNode.IsNull())
       {
         continue;
       }
 
       AddDataNodeToAllRenderer(dataNode);
     }
   }
 }
 
 void QmitkRenderWindowDataStorageListModel::SetCurrentRenderer(mitk::BaseRenderer* baseRenderer)
 {
   if (m_BaseRenderer == baseRenderer)
   {
     return;
   }
 
   m_BaseRenderer = baseRenderer;
   if (!m_BaseRenderer.IsExpired())
   {
     UpdateModelData();
   }
 }
 
-mitk::BaseRenderer* QmitkRenderWindowDataStorageListModel::GetCurrentRenderer() const
+mitk::BaseRenderer::Pointer QmitkRenderWindowDataStorageListModel::GetCurrentRenderer() const
 {
-  if (m_BaseRenderer.IsExpired())
-  {
-    return nullptr;
-  }
-
-  return m_BaseRenderer.Lock().GetPointer();
+  return m_BaseRenderer.Lock();
 }
 
 void QmitkRenderWindowDataStorageListModel::AddDataNodeToAllRenderer(mitk::DataNode* dataNode)
 {
   m_RenderWindowLayerController->InsertLayerNode(dataNode);
 }
 
 void QmitkRenderWindowDataStorageListModel::UpdateModelData()
 {
-  if (!m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
-    if (!m_BaseRenderer.IsExpired())
+    auto baseRenderer = m_BaseRenderer.Lock();
+
+    if (baseRenderer.IsNotNull())
     {
-      auto baseRenderer = m_BaseRenderer.Lock();
       // update the model, so that it will be filled with the nodes of the new data storage
       beginResetModel();
       // get the current layer stack of the given base renderer
       m_LayerStack = mitk::RenderWindowLayerUtilities::GetLayerStack(dataStorage, baseRenderer, true);
       endResetModel();
     }
   }
 }
diff --git a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp
index 8274403471..70a3d1c434 100644
--- a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp
+++ b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp
@@ -1,601 +1,600 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // render window manager UI module
 #include "QmitkRenderWindowDataStorageTreeModel.h"
 
 // mitk core
 #include <QmitkDataStorageTreeModelInternalItem.h>
 
 // qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 #include "QmitkMimeTypes.h"
 #include "QmitkNodeDescriptorManager.h"
 
 QmitkRenderWindowDataStorageTreeModel::QmitkRenderWindowDataStorageTreeModel(QObject* parent /*= nullptr*/)
   : QmitkAbstractDataStorageModel(parent)
   , m_Root(nullptr)
 {
   m_RenderWindowLayerController = std::make_unique<mitk::RenderWindowLayerController>();
   ResetTree();
 }
 
 void QmitkRenderWindowDataStorageTreeModel::DataStorageChanged()
 {
   m_RenderWindowLayerController->SetDataStorage(m_DataStorage.Lock());
   ResetTree();
   UpdateModelData();
 }
 
 void QmitkRenderWindowDataStorageTreeModel::NodePredicateChanged()
 {
   ResetTree();
   UpdateModelData();
 }
 
 void QmitkRenderWindowDataStorageTreeModel::NodeAdded(const mitk::DataNode* node)
 {
   for (const auto renderer : m_ControlledRenderer)
   {
     // add the node to each render window
     mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(const_cast<mitk::DataNode*>(node), renderer);
   }
 
-  if (!m_BaseRenderer.IsExpired())
+  auto baseRenderer = m_BaseRenderer.Lock();
+
+  if (baseRenderer.IsNotNull())
   {
-    auto baseRenderer = m_BaseRenderer.Lock();
     AddNodeInternal(node, baseRenderer);
   }
 }
 
 void QmitkRenderWindowDataStorageTreeModel::NodeChanged(const mitk::DataNode* node)
 {
   auto item = m_Root->Find(node);
   if (nullptr != item)
   {
     auto parentItem = item->GetParent();
     // as the root node should not be removed one should always have a parent item
     if (nullptr == parentItem)
     {
       return;
     }
 
     auto index = createIndex(item->GetIndex(), 0, item);
     emit dataChanged(index, index);
   }
 }
 
 void QmitkRenderWindowDataStorageTreeModel::NodeRemoved(const mitk::DataNode* node)
 {
   RemoveNodeInternal(node);
 }
 
 QModelIndex QmitkRenderWindowDataStorageTreeModel::index(int row, int column, const QModelIndex& parent) const
 {
   auto item = GetItemByIndex(parent);
   if (nullptr != item)
   {
     item = item->GetChild(row);
   }
 
   if (nullptr == item)
   {
     return QModelIndex();
   }
 
   return createIndex(row, column, item);
 }
 
 QModelIndex QmitkRenderWindowDataStorageTreeModel::parent(const QModelIndex& parent) const
 {
   auto item = GetItemByIndex(parent);
   if (nullptr != item)
   {
     item = item->GetParent();
   }
 
   if(nullptr == item)
   {
     return QModelIndex();
   }
 
   if (item == m_Root)
   {
     return QModelIndex();
   }
 
   return createIndex(item->GetIndex(), 0, item);
 }
 
 int QmitkRenderWindowDataStorageTreeModel::rowCount(const QModelIndex& parent /*= QModelIndex()*/) const
 {
   auto item = GetItemByIndex(parent);
   if (nullptr == item)
   {
     return 0;
   }
 
   return item->GetChildCount();
 }
 
 int QmitkRenderWindowDataStorageTreeModel::columnCount(const QModelIndex&/* parent = QModelIndex()*/) const
 {
   if (0 == m_Root->GetChildCount())
   {
     // no items stored, no need to display columns
     return 0;
   }
 
   return 1;
 }
 
 QVariant QmitkRenderWindowDataStorageTreeModel::data(const QModelIndex& index, int role) const
 {
-  if (m_BaseRenderer.IsExpired())
+  auto baseRenderer = m_BaseRenderer.Lock();
+
+  if (baseRenderer.IsNull())
   {
     return QVariant();
   }
 
-  auto baseRenderer = m_BaseRenderer.Lock();
-
   if (!index.isValid() || this != index.model())
   {
     return QVariant();
   }
 
   auto item = GetItemByIndex(index);
   if (nullptr == item)
   {
     return QVariant();
   }
 
   auto dataNode = item->GetDataNode();
   if (nullptr == dataNode)
   {
     return QVariant();
   }
 
   if (Qt::CheckStateRole == role)
   {
     bool visibility = false;
     dataNode->GetVisibility(visibility, baseRenderer);
     if (visibility)
     {
       return Qt::Checked;
     }
     else
     {
       return Qt::Unchecked;
     }
   }
   else if (Qt::DisplayRole == role)
   {
     return QVariant(QString::fromStdString(dataNode->GetName()));
   }
   else if (Qt::ToolTipRole == role)
   {
     return QVariant("Name of the data node.");
   }
   else if (Qt::DecorationRole == role)
   {
     QmitkNodeDescriptor* nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
     return nodeDescriptor->GetIcon(dataNode);
   }
   else if (Qt::UserRole == role || QmitkDataNodeRawPointerRole == role)
   {
     // user role always returns a reference to the data node,
     // which can be used to modify the data node in the data storage
     return QVariant::fromValue<mitk::DataNode*>(dataNode);
   }
   else if (QmitkDataNodeRole == role)
   {
     return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
   }
 
   return QVariant();
 }
 
 bool QmitkRenderWindowDataStorageTreeModel::setData(const QModelIndex& index, const QVariant& value, int role /*= Qt::EditRole*/)
 {
-  if (m_BaseRenderer.IsExpired())
+  auto baseRenderer = m_BaseRenderer.Lock();
+
+  if (baseRenderer.IsNull())
   {
     return false;
   }
 
-  auto baseRenderer = m_BaseRenderer.Lock();
-
   if (!index.isValid() || this != index.model())
   {
     return false;
   }
 
   auto item = GetItemByIndex(index);
   if (nullptr == item)
   {
     return false;
   }
 
   auto dataNode = item->GetDataNode();
   if (nullptr == dataNode)
   {
     return false;
   }
 
   if (Qt::EditRole == role && !value.toString().isEmpty())
   {
     dataNode->SetName(value.toString().toStdString().c_str());
     emit dataChanged(index, index);
     return true;
   }
   if (Qt::CheckStateRole == role)
   {
     Qt::CheckState newCheckState = static_cast<Qt::CheckState>(value.toInt());
     bool isVisible = newCheckState;
     dataNode->SetVisibility(isVisible, baseRenderer);
 
     emit dataChanged(index, index);
     mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
     return true;
   }
   return false;
 }
 
 Qt::ItemFlags QmitkRenderWindowDataStorageTreeModel::flags(const QModelIndex& index) const
 {
   if (this != index.model())
   {
     return Qt::NoItemFlags;
   }
 
   if (!index.isValid())
   {
     return Qt::ItemIsDropEnabled;
   }
 
   auto item = GetItemByIndex(index);
   if (nullptr == item)
   {
     return Qt::NoItemFlags;
   }
 
   const auto dataNode = item->GetDataNode();
   if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(dataNode))
   {
     return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
   }
 
   return Qt::NoItemFlags;
 }
 
 Qt::DropActions QmitkRenderWindowDataStorageTreeModel::supportedDropActions() const
 {
   return Qt::CopyAction | Qt::MoveAction;
 }
 
 Qt::DropActions QmitkRenderWindowDataStorageTreeModel::supportedDragActions() const
 {
   return Qt::CopyAction | Qt::MoveAction;
 }
 
 QStringList QmitkRenderWindowDataStorageTreeModel::mimeTypes() const
 {
   QStringList types = QAbstractItemModel::mimeTypes();
   types << QmitkMimeTypes::DataNodePtrs;
   return types;
 }
 
 QMimeData* QmitkRenderWindowDataStorageTreeModel::mimeData(const QModelIndexList& indexes) const
 {
   QMimeData* mimeData = new QMimeData();
   QByteArray encodedData;
 
   QDataStream stream(&encodedData, QIODevice::WriteOnly);
 
   for (const auto& index : indexes)
   {
     if (index.isValid())
     {
       auto dataNode = data(index, QmitkDataNodeRawPointerRole).value<mitk::DataNode*>();
       stream << reinterpret_cast<quintptr>(dataNode);
     }
   }
 
   mimeData->setData(QmitkMimeTypes::DataNodePtrs, encodedData);
   return mimeData;
 }
 
 bool QmitkRenderWindowDataStorageTreeModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int /*row*/, int /*column*/, const QModelIndex& parent)
 {
-  if (m_BaseRenderer.IsExpired())
+  auto baseRenderer = m_BaseRenderer.Lock();
+
+  if (baseRenderer.IsNull())
   {
     return false;
   }
 
-  auto baseRenderer = m_BaseRenderer.Lock();
-
   if (action == Qt::IgnoreAction)
   {
     return true;
   }
 
   if (!data->hasFormat(QmitkMimeTypes::DataNodePtrs))
   {
     return false;
   }
 
   if (!parent.isValid())
   {
     return false;
   }
 
   int layer = -1;
   auto dataNode = this->data(parent, QmitkDataNodeRawPointerRole).value<mitk::DataNode*>();
   if (nullptr != dataNode)
   {
     dataNode->GetIntProperty("layer", layer, baseRenderer);
   }
 
   auto dataNodeList = QmitkMimeTypes::ToDataNodePtrList(data);
   for (const auto& dataNode : qAsConst(dataNodeList))
   {
     m_RenderWindowLayerController->MoveNodeToPosition(dataNode, layer, baseRenderer);
   }
 
   ResetTree();
   UpdateModelData();
   AdjustLayerProperty();
   return true;
 }
 
 void QmitkRenderWindowDataStorageTreeModel::SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer)
 {
   m_RenderWindowLayerController->SetControlledRenderer(controlledRenderer);
   m_ControlledRenderer = controlledRenderer;
 
   ResetTree();
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   for (const auto& renderer : controlledRenderer)
   {
     if (nullptr == renderer)
     {
       continue;
     }
 
     auto allDataNodes = dataStorage->GetAll();
     for (const auto& dataNode : *allDataNodes)
     {
       // add the node to each render window
       mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(dataNode, renderer);
     }
   }
 }
 
 void QmitkRenderWindowDataStorageTreeModel::SetCurrentRenderer(mitk::BaseRenderer* baseRenderer)
 {
   if (m_BaseRenderer == baseRenderer)
   {
     return;
   }
 
   // base renderer changed
   // reset tree to build a new renderer-specific item hierarchy
   m_BaseRenderer = baseRenderer;
   ResetTree();
   UpdateModelData();
 }
 
-mitk::BaseRenderer* QmitkRenderWindowDataStorageTreeModel::GetCurrentRenderer() const
+mitk::BaseRenderer::Pointer QmitkRenderWindowDataStorageTreeModel::GetCurrentRenderer() const
 {
-  if (m_BaseRenderer.IsExpired())
-  {
-    return nullptr;
-  }
-
-  return m_BaseRenderer.Lock().GetPointer();
+  return m_BaseRenderer.Lock();
 }
 
 void QmitkRenderWindowDataStorageTreeModel::ResetTree()
 {
   beginResetModel();
   if (nullptr != m_Root)
   {
     m_Root->Delete();
   }
 
   mitk::DataNode::Pointer rootDataNode = mitk::DataNode::New();
   rootDataNode->SetName("Data Storage");
   m_Root = new QmitkDataStorageTreeModelInternalItem(rootDataNode);
   endResetModel();
 }
 
 void QmitkRenderWindowDataStorageTreeModel::UpdateModelData()
 {
-  if (!m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
-    if (!m_BaseRenderer.IsExpired())
-    {
-      auto baseRenderer = m_BaseRenderer.Lock();
+    auto baseRenderer = m_BaseRenderer.Lock();
 
+    if (baseRenderer.IsNotNull())
+    {
       mitk::NodePredicateAnd::Pointer combinedNodePredicate = mitk::RenderWindowLayerUtilities::GetRenderWindowPredicate(baseRenderer);
       auto filteredDataNodes = dataStorage->GetSubset(combinedNodePredicate);
       for (const auto& dataNode : *filteredDataNodes)
       {
         AddNodeInternal(dataNode, baseRenderer);
       }
     }
   }
 }
 
 void QmitkRenderWindowDataStorageTreeModel::AdjustLayerProperty()
 {
-  if (m_BaseRenderer.IsExpired())
+  auto baseRenderer = m_BaseRenderer.Lock();
+
+  if (baseRenderer.IsNull())
   {
     return;
   }
 
-  auto baseRenderer = m_BaseRenderer.Lock();
-
   std::vector<QmitkDataStorageTreeModelInternalItem*> treeAsVector;
   TreeToVector(m_Root, treeAsVector);
 
   int i = treeAsVector.size() - 1;
   for (auto it = treeAsVector.begin(); it != treeAsVector.end(); ++it)
   {
     auto dataNode = (*it)->GetDataNode();
     dataNode->SetIntProperty("layer", i, baseRenderer);
     --i;
   }
 }
 
 void QmitkRenderWindowDataStorageTreeModel::TreeToVector(QmitkDataStorageTreeModelInternalItem* parent, std::vector<QmitkDataStorageTreeModelInternalItem*>& treeAsVector) const
 {
   QmitkDataStorageTreeModelInternalItem* item;
   for (int i = 0; i < parent->GetChildCount(); ++i)
   {
     item = parent->GetChild(i);
     TreeToVector(item, treeAsVector);
     treeAsVector.push_back(item);
   }
 }
 
 void QmitkRenderWindowDataStorageTreeModel::AddNodeInternal(const mitk::DataNode* dataNode, const mitk::BaseRenderer* renderer)
 {
   if (nullptr == dataNode
    || m_DataStorage.IsExpired()
    || nullptr != m_Root->Find(dataNode))
   {
     return;
   }
 
   // find out if we have a root node
   auto parentItem = m_Root;
   QModelIndex index;
   auto parentDataNode = GetParentNode(dataNode);
 
   if (nullptr != parentDataNode) // no top level data node
   {
     parentItem = m_Root->Find(parentDataNode);
     if (nullptr == parentItem)
     {
       // parent node not contained in the tree; add it
       NodeAdded(parentDataNode);
       parentItem = m_Root->Find(parentDataNode);
       if (nullptr == parentItem)
       {
         // could not find and add the parent tree; abort
         return;
       }
     }
 
     // get the index of this parent with the help of the grand parent
     index = createIndex(parentItem->GetIndex(), 0, parentItem);
   }
 
   int firstRowWithASiblingBelow = 0;
   int nodeLayer = -1;
   dataNode->GetIntProperty("layer", nodeLayer, renderer);
   for (const auto& siblingItem : parentItem->GetChildren())
   {
     int siblingLayer = -1;
     auto siblingNode = siblingItem->GetDataNode();
     if (nullptr != siblingNode)
     {
       siblingNode->GetIntProperty("layer", siblingLayer, renderer);
     }
     if (nodeLayer > siblingLayer)
     {
       break;
     }
     ++firstRowWithASiblingBelow;
   }
 
   beginInsertRows(index, firstRowWithASiblingBelow, firstRowWithASiblingBelow);
   auto newNode = new QmitkDataStorageTreeModelInternalItem(const_cast<mitk::DataNode*>(dataNode));
   parentItem->InsertChild(newNode, firstRowWithASiblingBelow);
   endInsertRows();
 }
 
 void QmitkRenderWindowDataStorageTreeModel::RemoveNodeInternal(const mitk::DataNode* dataNode)
 {
   if (nullptr == dataNode
    || nullptr == m_Root)
   {
     return;
   }
 
   auto item = m_Root->Find(dataNode);
   if (nullptr == item)
   {
     return;
   }
 
   auto parentItem = item->GetParent();
   auto parentIndex = GetIndexByItem(parentItem);
 
   auto children = item->GetChildren();
   beginRemoveRows(parentIndex, item->GetIndex(), item->GetIndex());
   parentItem->RemoveChild(item);
   delete item;
   endRemoveRows();
 
   if (!children.empty())
   {
     // rebuild tree because children could not be at the top level
     ResetTree();
     UpdateModelData();
   }
 }
 
 mitk::DataNode* QmitkRenderWindowDataStorageTreeModel::GetParentNode(const mitk::DataNode* node) const
 {
   mitk::DataNode* dataNode = nullptr;
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return dataNode;
   }
 
-  auto sources = m_DataStorage.Lock()->GetSources(node);
+  auto sources = dataStorage->GetSources(node);
   if (sources->empty())
   {
     return dataNode;
   }
 
   return sources->front();
 }
 
 QmitkDataStorageTreeModelInternalItem* QmitkRenderWindowDataStorageTreeModel::GetItemByIndex(const QModelIndex& index) const
 {
   if (index.isValid())
   {
     return static_cast<QmitkDataStorageTreeModelInternalItem*>(index.internalPointer());
   }
 
   return m_Root;
 }
 
 QModelIndex QmitkRenderWindowDataStorageTreeModel::GetIndexByItem(QmitkDataStorageTreeModelInternalItem* item) const
 {
   if (item == m_Root)
   {
     return QModelIndex();
   }
 
   return createIndex(item->GetIndex(), 0, item);
 }
diff --git a/Modules/Segmentation/Algorithms/mitkContourModelSetToImageFilter.cpp b/Modules/Segmentation/Algorithms/mitkContourModelSetToImageFilter.cpp
index 3a2d7f7262..5dfd573cd4 100644
--- a/Modules/Segmentation/Algorithms/mitkContourModelSetToImageFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkContourModelSetToImageFilter.cpp
@@ -1,271 +1,271 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkContourModelSetToImageFilter.h"
 
 #include <mitkContourModelSet.h>
 #include <mitkContourModelUtils.h>
 #include <mitkExtractSliceFilter.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkProgressBar.h>
 #include <mitkTimeHelper.h>
 
 #include <mitkVtkImageOverwrite.h>
 
 mitk::ContourModelSetToImageFilter::ContourModelSetToImageFilter()
   : m_MakeOutputBinary(true), m_TimeStep(0), m_ReferenceImage(nullptr)
 {
   // Create the output.
   itk::DataObject::Pointer output = this->MakeOutput(0);
   Superclass::SetNumberOfRequiredInputs(1);
   Superclass::SetNumberOfRequiredOutputs(1);
   Superclass::SetNthOutput(0, output);
 }
 
 mitk::ContourModelSetToImageFilter::~ContourModelSetToImageFilter()
 {
 }
 
 void mitk::ContourModelSetToImageFilter::GenerateInputRequestedRegion()
 {
   mitk::Image *output = this->GetOutput();
   if ((output->IsInitialized() == false))
     return;
 
   GenerateTimeInInputRegion(output, const_cast<mitk::Image *>(m_ReferenceImage));
 }
 
 void mitk::ContourModelSetToImageFilter::GenerateOutputInformation()
 {
   mitk::Image::Pointer output = this->GetOutput();
 
   itkDebugMacro(<< "GenerateOutputInformation()");
 
   if ((m_ReferenceImage == nullptr) || (m_ReferenceImage->IsInitialized() == false) ||
       (m_ReferenceImage->GetTimeGeometry() == nullptr))
     return;
 
   if (m_MakeOutputBinary)
   {
     output->Initialize(mitk::MakeScalarPixelType<unsigned char>(), *m_ReferenceImage->GetTimeGeometry(), 1);
   }
   else
   {
     output->Initialize(m_ReferenceImage->GetPixelType(), *m_ReferenceImage->GetTimeGeometry());
   }
 
   output->SetPropertyList(m_ReferenceImage->GetPropertyList()->Clone());
 }
 
 itk::DataObject::Pointer mitk::ContourModelSetToImageFilter::MakeOutput(DataObjectPointerArraySizeType /*idx*/)
 {
   return OutputType::New().GetPointer();
 }
 
 itk::DataObject::Pointer mitk::ContourModelSetToImageFilter::MakeOutput(const DataObjectIdentifierType &name)
 {
   itkDebugMacro("MakeOutput(" << name << ")");
   if (this->IsIndexedOutputName(name))
   {
     return this->MakeOutput(this->MakeIndexFromOutputName(name));
   }
   return OutputType::New().GetPointer();
 }
 
 const mitk::ContourModelSet *mitk::ContourModelSetToImageFilter::GetInput(void)
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return nullptr;
   }
 
   return static_cast<const mitk::ContourModelSet *>(this->ProcessObject::GetInput(0));
 }
 
 void mitk::ContourModelSetToImageFilter::SetInput(const ContourModelSet *input)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(0, const_cast<mitk::ContourModelSet *>(input));
 }
 
 void mitk::ContourModelSetToImageFilter::SetImage(const mitk::Image *refImage)
 {
   m_ReferenceImage = refImage;
 }
 
 const mitk::Image *mitk::ContourModelSetToImageFilter::GetImage(void)
 {
   return m_ReferenceImage;
 }
 
 void mitk::ContourModelSetToImageFilter::GenerateData()
 {
   auto *contourSet = const_cast<mitk::ContourModelSet *>(this->GetInput());
 
   // Initializing progressbar
   unsigned int num_contours = contourSet->GetContourModelList()->size();
   mitk::ProgressBar::GetInstance()->AddStepsToDo(num_contours);
 
   // Assure that the volume data of the output is set (fill volume with zeros)
   this->InitializeOutputEmpty();
 
   mitk::Image::Pointer outputImage = const_cast<mitk::Image *>(this->GetOutput());
 
   if (outputImage.IsNull() || outputImage->IsInitialized() == false || !outputImage->IsVolumeSet(m_TimeStep))
   {
     mitkThrow() << "Error creating output for specified image!";
   }
 
   if (!contourSet || contourSet->GetContourModelList()->size() == 0)
   {
     mitkThrow() << "No contours specified!";
   }
 
   mitk::BaseGeometry *outputImageGeo = outputImage->GetGeometry(m_TimeStep);
 
   // Create mitkVtkImageOverwrite which is needed to write the slice back into the volume
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
   // Create ExtractSliceFilter for extracting the corresponding slices from the volume
   mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput(outputImage);
   extractor->SetTimeStep(m_TimeStep);
   extractor->SetResliceTransformByGeometry(outputImageGeo);
 
   // Fill each contour of the contourmodelset into the image
   auto it = contourSet->Begin();
   auto end = contourSet->End();
   while (it != end)
   {
     mitk::ContourModel *contour = it->GetPointer();
 
     // 1. Create slice geometry using the contour points
     mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
     mitk::Point3D point3D, tempPoint;
     mitk::Vector3D normal;
 
     mitk::Image::Pointer slice;
 
     int sliceIndex;
     bool isFrontside = true;
     bool isRotated = false;
 
     // Determine plane orientation
     point3D = contour->GetVertexAt(0)->Coordinates;
     tempPoint = contour->GetVertexAt(contour->GetNumberOfVertices() * 0.25)->Coordinates;
     mitk::Vector3D vec = point3D - tempPoint;
     vec.Normalize();
     outputImageGeo->WorldToIndex(point3D, point3D);
 
     mitk::PlaneGeometry::PlaneOrientation orientation;
     if (mitk::Equal(vec[0], 0))
     {
       orientation = mitk::PlaneGeometry::Sagittal;
       sliceIndex = point3D[0];
     }
     else if (mitk::Equal(vec[1], 0))
     {
-      orientation = mitk::PlaneGeometry::Frontal;
+      orientation = mitk::PlaneGeometry::Coronal;
       sliceIndex = point3D[1];
     }
     else if (mitk::Equal(vec[2], 0))
     {
       orientation = mitk::PlaneGeometry::Axial;
       sliceIndex = point3D[2];
     }
     else
     {
       // TODO Maybe rotate geometry to extract slice?
       MITK_ERROR
-        << "Cannot detect correct slice number! Only axial, sagittal and frontal oriented contours are supported!";
+        << "Cannot detect correct slice number! Only axial, sagittal and coronal oriented contours are supported!";
       return;
     }
 
     // Initialize plane using the detected orientation
     plane->InitializeStandardPlane(outputImageGeo, orientation, sliceIndex, isFrontside, isRotated);
     point3D = plane->GetOrigin();
     normal = plane->GetNormal();
     normal.Normalize();
     point3D += normal * 0.5; // pixelspacing is 1, so half the spacing is 0.5
     plane->SetOrigin(point3D);
 
     // 2. Extract slice at the given position
     extractor->SetWorldGeometry(plane);
     extractor->SetVtkOutputRequest(false);
     reslice->SetOverwriteMode(false);
 
     extractor->Modified();
     extractor->Update();
 
     slice = extractor->GetOutput();
     slice->DisconnectPipeline();
 
     // 3. Fill contour into slice
     mitk::ContourModel::Pointer projectedContour =
       mitk::ContourModelUtils::ProjectContourTo2DSlice(slice, contour);
     mitk::ContourModelUtils::FillContourInSlice(projectedContour, slice, outputImage);
 
     // 4. Write slice back into image volume
     reslice->SetInputSlice(slice->GetVtkImageData());
 
     // set overwrite mode to true to write back to the image volume
     reslice->SetOverwriteMode(true);
     reslice->Modified();
 
     extractor->Modified();
     extractor->Update();
 
     reslice->SetInputSlice(nullptr);
 
     // Progress
     mitk::ProgressBar::GetInstance()->Progress();
 
     ++it;
   }
 
   outputImage->Modified();
   outputImage->GetVtkImageData()->Modified();
 }
 
 void mitk::ContourModelSetToImageFilter::InitializeOutputEmpty()
 {
   // Initialize the output's volume with zeros
   mitk::Image *output = this->GetOutput();
   unsigned int byteSize = output->GetPixelType().GetSize();
 
   if (output->GetDimension() < 4)
   {
     for (unsigned int dim = 0; dim < output->GetDimension(); ++dim)
     {
       byteSize *= output->GetDimension(dim);
     }
 
     mitk::ImageWriteAccessor writeAccess(output, output->GetVolumeData(0));
 
     memset(writeAccess.GetData(), 0, byteSize);
   }
   else
   {
     // if we have a time-resolved image we need to set memory to 0 for each time step
     for (unsigned int dim = 0; dim < 3; ++dim)
     {
       byteSize *= output->GetDimension(dim);
     }
 
     for (unsigned int volumeNumber = 0; volumeNumber < output->GetDimension(3); volumeNumber++)
     {
       mitk::ImageWriteAccessor writeAccess(output, output->GetVolumeData(volumeNumber));
 
       memset(writeAccess.GetData(), 0, byteSize);
     }
   }
 }
diff --git a/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp b/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
index ae2d461fcd..969e1c7e84 100644
--- a/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
@@ -1,195 +1,196 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkFeatureBasedEdgeDetectionFilter.h"
 
 #include <SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.h>
 #include <mitkITKImageImport.h>
 #include <mitkImage.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageStatisticsCalculator.h>
 #include <mitkImageToUnstructuredGridFilter.h>
 #include <mitkProgressBar.h>
 #include <mitkUnstructuredGrid.h>
 #include <SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.h>
 #include <mitkImageMaskGenerator.h>
 #include <mitkImageStatisticsConstants.h>
 
 #include <itkBinaryBallStructuringElement.h>
 #include <itkBinaryContourImageFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkDilateObjectMorphologyImageFilter.h>
 #include <itkErodeObjectMorphologyImageFilter.h>
 #include <itkImage.h>
 
 mitk::FeatureBasedEdgeDetectionFilter::FeatureBasedEdgeDetectionFilter()
 {
   this->SetNumberOfRequiredInputs(1);
 
   this->SetNumberOfIndexedOutputs(1);
 }
 
 mitk::FeatureBasedEdgeDetectionFilter::~FeatureBasedEdgeDetectionFilter()
 {
 }
 
 void mitk::FeatureBasedEdgeDetectionFilter::GenerateData()
 {
   mitk::Image::ConstPointer image = ImageToUnstructuredGridFilter::GetInput();
 
   if (m_SegmentationMask.IsNull())
   {
     MITK_WARN << "Please set a segmentation mask first" << std::endl;
     return;
   }
   // First create a threshold segmentation of the image. The threshold is determined
   // by the mean +/- stddev of the pixel values that are covered by the segmentation mask
 
   // Compute mean and stdDev based on the current segmentation
   mitk::ImageStatisticsCalculator::Pointer statCalc = mitk::ImageStatisticsCalculator::New();
   statCalc->SetInputImage(image);
 
   mitk::ImageMaskGenerator::Pointer imgMask = mitk::ImageMaskGenerator::New();
+  imgMask->SetInputImage(image);
   imgMask->SetImageMask(m_SegmentationMask);
 
   auto stats = statCalc->GetStatistics()->GetStatisticsForTimeStep(0);
   double mean = stats.GetValueConverted<double>(mitk::ImageStatisticsConstants::MEAN());
   double stdDev = stats.GetValueConverted<double>(mitk::ImageStatisticsConstants::STANDARDDEVIATION());
 
   double upperThreshold = mean + stdDev;
   double lowerThreshold = mean - stdDev;
 
   // Perform thresholding
   mitk::Image::Pointer thresholdImage = mitk::Image::New();
   AccessByItk_3(image.GetPointer(), ITKThresholding, lowerThreshold, upperThreshold, thresholdImage)
 
     mitk::ProgressBar::GetInstance()
       ->Progress(2);
 
   // Postprocess threshold segmentation
   // First a closing will be executed
   mitk::Image::Pointer closedImage = mitk::Image::New();
   AccessByItk_1(thresholdImage, ThreadedClosing, closedImage);
 
   // Then we will holes that might exist
   mitk::MorphologicalOperations::FillHoles(closedImage);
 
   mitk::ProgressBar::GetInstance()->Progress();
 
   // Extract the binary edges of the resulting segmentation
   mitk::Image::Pointer edgeImage = mitk::Image::New();
   AccessByItk_1(closedImage, ContourSearch, edgeImage);
 
   // Convert the edge image into an unstructured grid
   mitk::ImageToUnstructuredGridFilter::Pointer i2UFilter = mitk::ImageToUnstructuredGridFilter::New();
   i2UFilter->SetInput(edgeImage);
   i2UFilter->SetThreshold(1.0);
   i2UFilter->Update();
 
   m_PointGrid = this->GetOutput();
   if (m_PointGrid.IsNull())
     m_PointGrid = mitk::UnstructuredGrid::New();
 
   m_PointGrid->SetVtkUnstructuredGrid(i2UFilter->GetOutput()->GetVtkUnstructuredGrid());
 
   mitk::ProgressBar::GetInstance()->Progress();
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::FeatureBasedEdgeDetectionFilter::ThreadedClosing(itk::Image<TPixel, VImageDimension> *originalImage,
                                                             mitk::Image::Pointer &result)
 {
   typedef itk::BinaryBallStructuringElement<TPixel, VImageDimension> myKernelType;
 
   myKernelType ball;
   ball.SetRadius(1);
   ball.CreateStructuringElement();
 
   typedef typename itk::Image<TPixel, VImageDimension> ImageType;
 
   typename itk::DilateObjectMorphologyImageFilter<ImageType, ImageType, myKernelType>::Pointer dilationFilter =
     itk::DilateObjectMorphologyImageFilter<ImageType, ImageType, myKernelType>::New();
   dilationFilter->SetInput(originalImage);
   dilationFilter->SetKernel(ball);
   dilationFilter->Update();
 
   typename itk::Image<TPixel, VImageDimension>::Pointer dilatedImage = dilationFilter->GetOutput();
 
   typename itk::ErodeObjectMorphologyImageFilter<ImageType, ImageType, myKernelType>::Pointer erodeFilter =
     itk::ErodeObjectMorphologyImageFilter<ImageType, ImageType, myKernelType>::New();
   erodeFilter->SetInput(dilatedImage);
   erodeFilter->SetKernel(ball);
   erodeFilter->Update();
 
   mitk::GrabItkImageMemory(erodeFilter->GetOutput(), result);
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::FeatureBasedEdgeDetectionFilter::ContourSearch(itk::Image<TPixel, VImageDimension> *originalImage,
                                                           mitk::Image::Pointer &result)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::BinaryContourImageFilter<ImageType, ImageType> binaryContourImageFilterType;
 
   typename binaryContourImageFilterType::Pointer binaryContourFilter = binaryContourImageFilterType::New();
   binaryContourFilter->SetInput(originalImage);
   binaryContourFilter->SetForegroundValue(1);
   binaryContourFilter->SetBackgroundValue(0);
   binaryContourFilter->Update();
 
   typename itk::Image<TPixel, VImageDimension>::Pointer itkImage = itk::Image<TPixel, VImageDimension>::New();
   itkImage->Graft(binaryContourFilter->GetOutput());
 
   mitk::GrabItkImageMemory(itkImage, result);
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::FeatureBasedEdgeDetectionFilter::ITKThresholding(const itk::Image<TPixel, VImageDimension> *originalImage,
                                                             double lower,
                                                             double upper,
                                                             mitk::Image::Pointer &result)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<unsigned short, VImageDimension> SegmentationType;
   typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
 
   if (typeid(TPixel) != typeid(float) && typeid(TPixel) != typeid(double))
   {
     // round the thresholds if we have nor a float or double image
     lower = std::floor(lower + 0.5);
     upper = std::floor(upper - 0.5);
   }
   if (lower >= upper)
   {
     upper = lower;
   }
 
   typename ThresholdFilterType::Pointer filter = ThresholdFilterType::New();
   filter->SetInput(originalImage);
   filter->SetLowerThreshold(lower);
   filter->SetUpperThreshold(upper);
   filter->SetInsideValue(1);
   filter->SetOutsideValue(0);
   filter->Update();
 
   mitk::GrabItkImageMemory(filter->GetOutput(), result);
 }
 
 void mitk::FeatureBasedEdgeDetectionFilter::SetSegmentationMask(mitk::Image::Pointer segmentation)
 {
   this->m_SegmentationMask = segmentation;
 }
 
 void mitk::FeatureBasedEdgeDetectionFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
 }
diff --git a/Modules/Segmentation/Controllers/mitkToolManager.cpp b/Modules/Segmentation/Controllers/mitkToolManager.cpp
index 4a71cac9a9..bf4b30c3bf 100644
--- a/Modules/Segmentation/Controllers/mitkToolManager.cpp
+++ b/Modules/Segmentation/Controllers/mitkToolManager.cpp
@@ -1,603 +1,596 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkToolManager.h"
 #include "mitkToolManagerProvider.h"
 #include "mitkCoreObjectFactory.h"
 
 #include <itkCommand.h>
 #include <itkObjectFactoryBase.h>
 
 #include <list>
 
 #include "mitkInteractionEventObserver.h"
 #include "mitkSegTool2D.h"
 #include "mitkRenderingManager.h"
 #include "mitkSliceNavigationController.h"
 
 #include "usGetModuleContext.h"
 #include "usModuleContext.h"
 
 mitk::ToolManager::ToolManager(DataStorage *storage)
   : m_ActiveTool(nullptr), m_ActiveToolID(-1), m_RegisteredClients(0), m_DataStorage(storage)
 {
   CoreObjectFactory::GetInstance(); // to make sure a CoreObjectFactory was instantiated (and in turn, possible tools
                                     // are registered) - bug 1029
   this->InitializeTools();
 }
 
 void mitk::ToolManager::EnsureTimeObservation()
 {
   if (nullptr != mitk::RenderingManager::GetInstance() && nullptr != mitk::RenderingManager::GetInstance()->GetTimeNavigationController())
   {
     auto timeController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
 
     m_LastTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
     auto currentTimeController = m_CurrentTimeNavigationController.Lock();
 
     if (timeController != currentTimeController)
     {
       if (currentTimeController.IsNotNull())
       {
         currentTimeController->RemoveObserver(m_TimePointObserverTag);
       }
 
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction(this, &ToolManager::OnTimeChanged);
       command->SetCallbackFunction(this, &ToolManager::OnTimeChangedConst);
       m_CurrentTimeNavigationController = timeController;
       m_TimePointObserverTag = timeController->AddObserver(SliceNavigationController::GeometryTimeEvent(nullptr,0), command);
     }
   }
 }
 
 void mitk::ToolManager::StopTimeObservation()
 {
   auto currentTimeController = m_CurrentTimeNavigationController.Lock();
 
   if (currentTimeController.IsNotNull())
   {
     currentTimeController->RemoveObserver(m_TimePointObserverTag);
     m_CurrentTimeNavigationController = nullptr;
     m_TimePointObserverTag = 0;
   }
 }
 
 mitk::ToolManager::~ToolManager()
 {
   for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
     (*dataIter)->RemoveObserver(m_WorkingDataObserverTags[(*dataIter)]);
 
   if (this->GetDataStorage() != nullptr)
     this->GetDataStorage()->RemoveNodeEvent.RemoveListener(
       mitk::MessageDelegate1<ToolManager, const mitk::DataNode *>(this, &ToolManager::OnNodeRemoved));
 
   if (m_ActiveTool)
   {
     m_ActiveTool->Deactivated();
     m_ActiveToolRegistration.Unregister();
 
     m_ActiveTool = nullptr;
     m_ActiveToolID = -1; // no tool active
 
     ActiveToolChanged.Send();
   }
   for (auto observerTagMapIter = m_ReferenceDataObserverTags.begin();
        observerTagMapIter != m_ReferenceDataObserverTags.end();
        ++observerTagMapIter)
   {
     observerTagMapIter->first->RemoveObserver(observerTagMapIter->second);
   }
   this->StopTimeObservation();
 }
 
 void mitk::ToolManager::InitializeTools()
 {
   // clear all previous tool pointers (tools may be still activated from another recently used plugin)
   if (m_ActiveTool)
   {
     m_ActiveTool->Deactivated();
     m_ActiveToolRegistration.Unregister();
 
     m_ActiveTool = nullptr;
     m_ActiveToolID = -1; // no tool active
 
     ActiveToolChanged.Send();
   }
   m_Tools.clear();
   // get a list of all known mitk::Tools
   std::list<itk::LightObject::Pointer> thingsThatClaimToBeATool = itk::ObjectFactoryBase::CreateAllInstance("mitkTool");
 
   // remember these tools
   for (auto iter = thingsThatClaimToBeATool.begin();
        iter != thingsThatClaimToBeATool.end();
        ++iter)
   {
     if (auto *tool = dynamic_cast<Tool *>(iter->GetPointer()))
     {
       tool->InitializeStateMachine();
       tool->SetToolManager(this); // important to call right after instantiation
       tool->ErrorMessage += MessageDelegate1<mitk::ToolManager, std::string>(this, &ToolManager::OnToolErrorMessage);
       tool->GeneralMessage +=
         MessageDelegate1<mitk::ToolManager, std::string>(this, &ToolManager::OnGeneralToolMessage);
       m_Tools.push_back(tool);
     }
   }
 }
 
 void mitk::ToolManager::OnToolErrorMessage(std::string s)
 {
   this->ToolErrorMessage(s);
 }
 
 void mitk::ToolManager::OnGeneralToolMessage(std::string s)
 {
   this->GeneralToolMessage(s);
 }
 
 const mitk::ToolManager::ToolVectorTypeConst mitk::ToolManager::GetTools()
 {
   ToolVectorTypeConst resultList;
 
   for (auto iter = m_Tools.begin(); iter != m_Tools.end(); ++iter)
   {
     resultList.push_back(iter->GetPointer());
   }
 
   return resultList;
 }
 
 mitk::Tool *mitk::ToolManager::GetToolById(int id)
 {
   try
   {
     return m_Tools.at(id);
   }
   catch (const std::exception &)
   {
     return nullptr;
   }
 }
 
 bool mitk::ToolManager::ActivateTool(int id)
 {
   const auto workingDataNode = this->GetWorkingData(0);
   const mitk::BaseData* workingData = nullptr;
   if (nullptr != workingDataNode)
   {
     workingData = workingDataNode->GetData();
   }
 
   const auto referenceDataNode = this->GetReferenceData(0);
   const mitk::BaseData* referenceData = nullptr;
   if (nullptr != referenceDataNode)
   {
     referenceData = referenceDataNode->GetData();
   }
 
   if (id != -1 && !this->GetToolById(id)->CanHandle(referenceData, workingData))
     return false;
 
   if (this->GetDataStorage())
   {
     this->GetDataStorage()->RemoveNodeEvent.AddListener(
       mitk::MessageDelegate1<ToolManager, const mitk::DataNode *>(this, &ToolManager::OnNodeRemoved));
   }
 
   if (GetToolById(id) == m_ActiveTool)
     return true; // no change needed
 
   static int nextTool = -1;
   nextTool = id;
 
   static bool inActivateTool = false;
   if (inActivateTool)
   {
     return true;
   }
   inActivateTool = true;
 
   while (nextTool != m_ActiveToolID)
   {
     // Deactivate all other active tools to ensure a globally single active tool
     for (const auto& toolManager : ToolManagerProvider::GetInstance()->GetToolManagers())
     {
       if (nullptr != toolManager.second->m_ActiveTool)
       {
         toolManager.second->m_ActiveTool->Deactivated();
         toolManager.second->m_ActiveToolRegistration.Unregister();
 
         // The active tool of *this* ToolManager is handled below this loop
         if (this != toolManager.second)
         {
           toolManager.second->m_ActiveTool = nullptr;
           toolManager.second->m_ActiveToolID = -1;
           toolManager.second->ActiveToolChanged.Send();
         }
       }
     }
 
     m_ActiveTool = GetToolById(nextTool);
     m_ActiveToolID = m_ActiveTool ? nextTool : -1; // current ID if tool is valid, otherwise -1
 
     ActiveToolChanged.Send();
 
     if (m_ActiveTool)
     {
       this->EnsureTimeObservation();
       if (m_RegisteredClients > 0)
       {
         m_ActiveTool->Activated();
         m_ActiveToolRegistration =
           us::GetModuleContext()->RegisterService<InteractionEventObserver>(m_ActiveTool, us::ServiceProperties());
       }
     }
   }
 
   inActivateTool = false;
   return (m_ActiveTool != nullptr);
 }
 
 void mitk::ToolManager::SetReferenceData(DataVectorType data)
 {
   if (data != m_ReferenceData)
   {
     // remove observers from old nodes
     for (auto dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter)
     {
       auto searchIter = m_ReferenceDataObserverTags.find(*dataIter);
       if (searchIter != m_ReferenceDataObserverTags.end())
       {
         (*dataIter)->RemoveObserver(searchIter->second);
       }
     }
 
     m_ReferenceData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_ReferenceDataObserverTags.clear();
     for (auto dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter)
     {
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction(this, &ToolManager::OnOneOfTheReferenceDataDeleted);
       command->SetCallbackFunction(this, &ToolManager::OnOneOfTheReferenceDataDeletedConst);
       m_ReferenceDataObserverTags.insert(
         std::pair<DataNode *, unsigned long>((*dataIter), (*dataIter)->AddObserver(itk::DeleteEvent(), command)));
     }
 
     ReferenceDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::OnOneOfTheReferenceDataDeletedConst(const itk::Object *caller, const itk::EventObject &e)
 {
   OnOneOfTheReferenceDataDeleted(const_cast<itk::Object *>(caller), e);
 }
 
 void mitk::ToolManager::OnOneOfTheReferenceDataDeleted(itk::Object *caller, const itk::EventObject &itkNotUsed(e))
 {
   DataVectorType v;
 
   for (auto dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter)
   {
     if ((void *)(*dataIter) != (void *)caller)
     {
       v.push_back(*dataIter);
     }
     else
     {
       m_ReferenceDataObserverTags.erase(*dataIter); // no tag to remove anymore
     }
   }
   this->SetReferenceData(v);
 }
 
 void mitk::ToolManager::SetReferenceData(DataNode *data)
 {
   DataVectorType v;
   if (data)
   {
     v.push_back(data);
   }
   SetReferenceData(v);
 }
 
 void mitk::ToolManager::SetWorkingData(DataVectorType data)
 {
   if (data != m_WorkingData)
   {
     // remove observers from old nodes
     for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
     {
       auto searchIter = m_WorkingDataObserverTags.find(*dataIter);
       if (searchIter != m_WorkingDataObserverTags.end())
       {
         (*dataIter)->RemoveObserver(searchIter->second);
       }
     }
 
     m_WorkingData = data;
     // TODO tell active tool?
 
     // Quick workaround for bug #16598
     if (m_WorkingData.empty())
       this->ActivateTool(-1);
     // workaround end
 
     // attach new observers
     m_WorkingDataObserverTags.clear();
     for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
     {
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction(this, &ToolManager::OnOneOfTheWorkingDataDeleted);
       command->SetCallbackFunction(this, &ToolManager::OnOneOfTheWorkingDataDeletedConst);
       m_WorkingDataObserverTags.insert(
         std::pair<DataNode *, unsigned long>((*dataIter), (*dataIter)->AddObserver(itk::DeleteEvent(), command)));
     }
 
     WorkingDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::OnOneOfTheWorkingDataDeletedConst(const itk::Object *caller, const itk::EventObject &e)
 {
   OnOneOfTheWorkingDataDeleted(const_cast<itk::Object *>(caller), e);
 }
 
 void mitk::ToolManager::OnOneOfTheWorkingDataDeleted(itk::Object *caller, const itk::EventObject &itkNotUsed(e))
 {
   DataVectorType v;
 
   for (auto dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
   {
     if ((void *)(*dataIter) != (void *)caller)
     {
       v.push_back(*dataIter);
     }
     else
     {
       m_WorkingDataObserverTags.erase(*dataIter); // no tag to remove anymore
     }
   }
   this->SetWorkingData(v);
 }
 
 void mitk::ToolManager::SetWorkingData(DataNode *data)
 {
   DataVectorType v;
 
   if (data) // don't allow for nullptr nodes
   {
     v.push_back(data);
   }
 
   SetWorkingData(v);
 }
 
 void mitk::ToolManager::SetRoiData(DataVectorType data)
 {
   if (data != m_RoiData)
   {
     // remove observers from old nodes
     for (auto dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter)
     {
       auto searchIter = m_RoiDataObserverTags.find(*dataIter);
       if (searchIter != m_RoiDataObserverTags.end())
       {
         (*dataIter)->RemoveObserver(searchIter->second);
       }
     }
 
     m_RoiData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_RoiDataObserverTags.clear();
     for (auto dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter)
     {
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction(this, &ToolManager::OnOneOfTheRoiDataDeleted);
       command->SetCallbackFunction(this, &ToolManager::OnOneOfTheRoiDataDeletedConst);
       m_RoiDataObserverTags.insert(
         std::pair<DataNode *, unsigned long>((*dataIter), (*dataIter)->AddObserver(itk::DeleteEvent(), command)));
     }
     RoiDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::SetRoiData(DataNode *data)
 {
   DataVectorType v;
 
   if (data)
   {
     v.push_back(data);
   }
   this->SetRoiData(v);
 }
 
 void mitk::ToolManager::OnOneOfTheRoiDataDeletedConst(const itk::Object *caller, const itk::EventObject &e)
 {
   OnOneOfTheRoiDataDeleted(const_cast<itk::Object *>(caller), e);
 }
 
 void mitk::ToolManager::OnOneOfTheRoiDataDeleted(itk::Object *caller, const itk::EventObject &itkNotUsed(e))
 {
   DataVectorType v;
 
   for (auto dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter)
   {
     if ((void *)(*dataIter) != (void *)caller)
     {
       v.push_back(*dataIter);
     }
     else
     {
       m_RoiDataObserverTags.erase(*dataIter); // no tag to remove anymore
     }
   }
   this->SetRoiData(v);
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetReferenceData()
 {
   return m_ReferenceData;
 }
 
 mitk::DataNode *mitk::ToolManager::GetReferenceData(int idx)
 {
   try
   {
     return m_ReferenceData.at(idx);
   }
   catch (const std::exception &)
   {
     return nullptr;
   }
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetWorkingData()
 {
   return m_WorkingData;
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetRoiData()
 {
   return m_RoiData;
 }
 
 mitk::DataNode *mitk::ToolManager::GetRoiData(int idx)
 {
   try
   {
     return m_RoiData.at(idx);
   }
   catch (const std::exception &)
   {
     return nullptr;
   }
 }
 
-mitk::DataStorage *mitk::ToolManager::GetDataStorage()
+mitk::DataStorage::Pointer mitk::ToolManager::GetDataStorage() const
 {
-  if (!m_DataStorage.IsExpired())
-  {
-    return m_DataStorage.Lock();
-  }
-  else
-  {
-    return nullptr;
-  }
+  return m_DataStorage.Lock();
 }
 
 void mitk::ToolManager::SetDataStorage(DataStorage &storage)
 {
   m_DataStorage = &storage;
 }
 
 mitk::DataNode *mitk::ToolManager::GetWorkingData(unsigned int idx)
 {
   if (m_WorkingData.empty())
     return nullptr;
 
   if (m_WorkingData.size() > idx)
     return m_WorkingData[idx];
 
   return nullptr;
 }
 
 int mitk::ToolManager::GetActiveToolID()
 {
   return m_ActiveToolID;
 }
 
 mitk::Tool *mitk::ToolManager::GetActiveTool()
 {
   return m_ActiveTool;
 }
 
 void mitk::ToolManager::RegisterClient()
 {
   if (m_RegisteredClients < 1)
   {
     if (m_ActiveTool)
     {
       m_ActiveTool->Activated();
       m_ActiveToolRegistration =
         us::GetModuleContext()->RegisterService<InteractionEventObserver>(m_ActiveTool, us::ServiceProperties());
     }
   }
   ++m_RegisteredClients;
 }
 
 void mitk::ToolManager::UnregisterClient()
 {
   if (m_RegisteredClients < 1)
     return;
 
   --m_RegisteredClients;
   if (m_RegisteredClients < 1)
   {
     if (m_ActiveTool)
     {
       m_ActiveTool->Deactivated();
       m_ActiveToolRegistration.Unregister();
     }
   }
 }
 
 int mitk::ToolManager::GetToolID(const Tool *tool)
 {
   int id(0);
   for (auto iter = m_Tools.begin(); iter != m_Tools.end(); ++iter, ++id)
   {
     if (tool == iter->GetPointer())
     {
       return id;
     }
   }
   return -1;
 }
 
 void mitk::ToolManager::OnNodeRemoved(const mitk::DataNode *node)
 {
   // check all storage vectors
   OnOneOfTheReferenceDataDeleted(const_cast<mitk::DataNode *>(node), itk::DeleteEvent());
   OnOneOfTheRoiDataDeleted(const_cast<mitk::DataNode *>(node), itk::DeleteEvent());
   OnOneOfTheWorkingDataDeleted(const_cast<mitk::DataNode *>(node), itk::DeleteEvent());
 }
 
 void mitk::ToolManager::OnTimeChanged(itk::Object* caller, const itk::EventObject& e)
 {
   this->OnTimeChangedConst(caller, e);
 }
 
 void mitk::ToolManager::OnTimeChangedConst(const itk::Object* caller, const itk::EventObject& /*e*/)
 {
   auto currentController = m_CurrentTimeNavigationController.Lock();
   if (caller == currentController)
   {
     const auto currentTimePoint = currentController->GetSelectedTimePoint();
     if (currentTimePoint != m_LastTimePoint)
     {
       m_LastTimePoint = currentTimePoint;
       SelectedTimePointChanged.Send();
     }
   }
 }
 
 mitk::TimePointType mitk::ToolManager::GetCurrentTimePoint() const
 {
   return m_LastTimePoint;
 }
diff --git a/Modules/Segmentation/Controllers/mitkToolManager.h b/Modules/Segmentation/Controllers/mitkToolManager.h
index 4cdfbf263a..9079e2579d 100644
--- a/Modules/Segmentation/Controllers/mitkToolManager.h
+++ b/Modules/Segmentation/Controllers/mitkToolManager.h
@@ -1,302 +1,302 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkToolManager_h_Included
 #define mitkToolManager_h_Included
 
 #include "mitkDataNode.h"
 #include "mitkDataStorage.h"
 #include "mitkTool.h"
 #include "mitkWeakPointer.h"
 #include <MitkSegmentationExports.h>
 
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 
 #include <vector>
 
 namespace mitk
 {
   class Image;
   class PlaneGeometry;
 
   /**
     \brief Manages and coordinates instances of mitk::Tool.
 
     \sa QmitkToolSelectionBox
     \sa Tool
     \sa QmitkSegmentationView
 
     \ingroup Interaction
     \ingroup ToolManagerEtAl
 
     There is a separate page describing the general design of QmitkSegmentationView: \ref QmitkSegmentationTechnicalPage
 
     This class creates and manages several instances of mitk::Tool.
 
     \li ToolManager creates instances of mitk::Tool by asking the itk::ObjectFactory to list all known implementations
     of mitk::Tool.
         As a result, one has to implement both a subclass of mitk::Tool and a matching subclass of
     itk::ObjectFactoryBase that is registered
         to the top-level itk::ObjectFactory. For an example, see mitkContourToolFactory.h. (this limitiation of
     one-class-one-factory is due
         to the implementation of itk::ObjectFactory).
         In MITK, the right place to register the factories to itk::ObjectFactory is the mitk::QMCoreObjectFactory or
     mitk::SBCoreObjectFactory.
 
      \li ToolManager knows a set of "reference" DataNodes and a set of "working" DataNodes. The first application are
     segmentation tools, where the
         reference is the original image and the working data the (kind of) binary segmentation. However, ToolManager is
     implemented more generally, so that
         there could be other tools that work, e.g., with surfaces.
 
 
     \li There is a set of events that are sent by ToolManager. At the moment these are TODO update documentation:
         - mitk::ToolReferenceDataChangedEvent whenever somebody calls SetReferenceData. Most of the time this actually
     means that the data has changed, but
           there might be cases where the same data is passed to SetReferenceData a second time, so don't rely on the
     assumption that something actually changed.
         - mitk::ToolSelectedEvent is sent when a (truly) different tool was activated. In reaction to this event you can
     ask for the active Tool using
           GetActiveTool or GetActiveToolID (where nullptr or -1 indicate that NO tool is active at the moment).
 
     Design descisions:
 
     \li Not a singleton, because there could be two functionalities using tools, each one with different
     reference/working data.
 
     $Author$
   */
   class MITKSEGMENTATION_EXPORT ToolManager : public itk::Object
   {
   public:
     typedef std::vector<Tool::Pointer> ToolVectorType;
     typedef std::vector<Tool::ConstPointer> ToolVectorTypeConst;
     typedef std::vector<DataNode *> DataVectorType; // has to be observed for delete events!
     typedef std::map<DataNode *, unsigned long> NodeTagMapType;
 
     Message<> NodePropertiesChanged;
     Message<> NewNodesGenerated;
     Message1<DataVectorType *> NewNodeObjectsGenerated;
 
     Message<> ActiveToolChanged;
     Message<> ReferenceDataChanged;
     Message<> WorkingDataChanged;
     Message<> RoiDataChanged;
     Message<> SelectedTimePointChanged;
 
     Message1<std::string> ToolErrorMessage;
     Message1<std::string> GeneralToolMessage;
 
     mitkClassMacroItkParent(ToolManager, itk::Object);
     mitkNewMacro1Param(ToolManager, DataStorage *);
 
     /**
       \brief Gives you a list of all tools.
       This is const on purpose.
      */
     const ToolVectorTypeConst GetTools();
 
     int GetToolID(const Tool *tool);
 
     /**
       \param id The tool of interest.
       Counting starts with 0.
     */
     Tool *GetToolById(int id);
 
     /**
       \param id The tool to activate. Provide -1 for disabling any tools.
       Counting starts with 0.
       Registeres a listner for NodeRemoved event at DataStorage (see mitk::ToolManager::OnNodeRemoved).
     */
     bool ActivateTool(int id);
 
     template <class T>
     int GetToolIdByToolType()
     {
       int id = 0;
       for (auto iter = m_Tools.begin(); iter != m_Tools.end(); ++iter, ++id)
       {
         if (dynamic_cast<T *>(iter->GetPointer()))
         {
           return id;
         }
       }
       return -1;
     }
 
     /**
       \return -1 for "No tool is active"
     */
     int GetActiveToolID();
 
     /**
       \return nullptr for "No tool is active"
     */
     Tool *GetActiveTool();
 
     /**
       \brief Set a list of data/images as reference objects.
     */
     void SetReferenceData(DataVectorType);
 
     /**
       \brief Set single data item/image as reference object.
     */
     void SetReferenceData(DataNode *);
 
     /**
       \brief Set a list of data/images as working objects.
     */
     void SetWorkingData(DataVectorType);
 
     /**
       \brief Set single data item/image as working object.
     */
     void SetWorkingData(DataNode *);
 
     /**
       \brief Set a list of data/images as roi objects.
     */
     void SetRoiData(DataVectorType);
 
     /**
       \brief Set a single data item/image as roi object.
     */
     void SetRoiData(DataNode *);
 
     /**
       \brief Get the list of reference data.
     */
     DataVectorType GetReferenceData();
 
     /**
       \brief Get the current reference data.
       \warning If there is a list of items, this method will only return the first list item.
     */
     DataNode *GetReferenceData(int);
 
     /**
       \brief Get the list of working data.
     */
     DataVectorType GetWorkingData();
 
     /**
       \brief Get the current working data.
       \warning If there is a list of items, this method will only return the first list item.
     */
     DataNode *GetWorkingData(unsigned int);
 
     /**
      \brief Get the current roi data
      */
     DataVectorType GetRoiData();
 
     /**
      \brief Get the roi data at position idx
      */
     DataNode *GetRoiData(int idx);
 
-    DataStorage *GetDataStorage();
+    DataStorage::Pointer GetDataStorage() const;
     void SetDataStorage(DataStorage &storage);
 
     /** Get the current selected time point of the RenderManager
     */
     TimePointType GetCurrentTimePoint() const;
 
     /**
       \brief Tell that someone is using tools.
       GUI elements should call this when they become active. This method increases an internal "client count".
      */
     void RegisterClient();
 
     /**
       \brief Tell that someone is NOT using tools.
       GUI elements should call this when they become active. This method increases an internal "client count".
      */
     void UnregisterClient();
 
     /** \brief Initialize all classes derived from mitk::Tool by itkObjectFactoy */
     void InitializeTools();
 
     void OnOneOfTheReferenceDataDeletedConst(const itk::Object *caller, const itk::EventObject &e);
     void OnOneOfTheReferenceDataDeleted(itk::Object *caller, const itk::EventObject &e);
 
     void OnOneOfTheWorkingDataDeletedConst(const itk::Object *caller, const itk::EventObject &e);
     void OnOneOfTheWorkingDataDeleted(itk::Object *caller, const itk::EventObject &e);
 
     void OnOneOfTheRoiDataDeletedConst(const itk::Object *caller, const itk::EventObject &e);
     void OnOneOfTheRoiDataDeleted(itk::Object *caller, const itk::EventObject &e);
 
     /**
      \brief Connected to tool's messages
 
      This method just resends error messages coming from any of the tools. This way clients (GUIs) only have to observe
      one message.
      */
     void OnToolErrorMessage(std::string s);
     void OnGeneralToolMessage(std::string s);
 
   protected:
     /**
       You may specify a list of tool "groups" that should be available for this ToolManager. Every Tool can report its
       group
       as a string. This constructor will try to find the tool's group inside the supplied string. If there is a match,
       the tool is accepted. Effectively, you can provide a human readable list like "default, lymphnodevolumetry,
       oldERISstuff".
     */
     ToolManager(DataStorage *storage); // purposely hidden
     ~ToolManager() override;
 
     ToolVectorType m_Tools;
 
     Tool *m_ActiveTool;
     int m_ActiveToolID;
     us::ServiceRegistration<InteractionEventObserver> m_ActiveToolRegistration;
 
     DataVectorType m_ReferenceData;
     NodeTagMapType m_ReferenceDataObserverTags;
 
     DataVectorType m_WorkingData;
     NodeTagMapType m_WorkingDataObserverTags;
 
     DataVectorType m_RoiData;
     NodeTagMapType m_RoiDataObserverTags;
 
     int m_RegisteredClients;
 
     WeakPointer<DataStorage> m_DataStorage;
 
     /// \brief Callback for NodeRemove events
     void OnNodeRemoved(const mitk::DataNode *node);
 
     /** Callback for time changed events*/
     void OnTimeChangedConst(const itk::Object* caller, const itk::EventObject& e);
     void OnTimeChanged(itk::Object* caller, const itk::EventObject& e);
 
     void EnsureTimeObservation();
     void StopTimeObservation();
 
   private:
     /** Time point of last detected change*/
     TimePointType m_LastTimePoint = 0;
     /** Tag of the observer that listens to time changes*/
     unsigned long m_TimePointObserverTag = 0;
     /** Pointer to the observed time stepper*/
     WeakPointer<SliceNavigationController> m_CurrentTimeNavigationController;
   };
 
 } // namespace
 
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp b/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
deleted file mode 100644
index 579561cfd0..0000000000
--- a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include "mitkAdaptiveRegionGrowingTool.h"
-#include "mitkImage.h"
-#include "mitkProperties.h"
-#include "mitkToolManager.h"
-// us
-#include <usGetModuleContext.h>
-#include <usModule.h>
-#include <usModuleContext.h>
-#include <usModuleResource.h>
-
-namespace mitk
-{
-  MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, AdaptiveRegionGrowingTool, "AdaptiveRegionGrowingTool");
-}
-
-mitk::AdaptiveRegionGrowingTool::AdaptiveRegionGrowingTool()
-{
-  m_PointSetNode = mitk::DataNode::New();
-  m_PointSetNode->GetPropertyList()->SetProperty("name", mitk::StringProperty::New("3D_Regiongrowing_Seedpoint"));
-  m_PointSetNode->GetPropertyList()->SetProperty("helper object", mitk::BoolProperty::New(true));
-  m_PointSet = mitk::PointSet::New();
-  m_PointSetNode->SetData(m_PointSet);
-}
-
-mitk::AdaptiveRegionGrowingTool::~AdaptiveRegionGrowingTool()
-{
-}
-
-bool mitk::AdaptiveRegionGrowingTool::CanHandle(const BaseData* referenceData, const BaseData* /*workingData*/) const
-{
-  if (referenceData == nullptr)
-    return false;
-
-  auto *image = dynamic_cast<const Image *>(referenceData);
-
-  if (image == nullptr)
-    return false;
-
-  if (image->GetDimension() < 3)
-    return false;
-
-  if (image->GetTimeSteps() > 1) //release quickfix for T28275
-    return false;
-
-  return true;
-}
-
-const char **mitk::AdaptiveRegionGrowingTool::GetXPM() const
-{
-  return nullptr;
-}
-
-const char *mitk::AdaptiveRegionGrowingTool::GetName() const
-{
-  return "Region Growing 3D";
-}
-
-us::ModuleResource mitk::AdaptiveRegionGrowingTool::GetIconResource() const
-{
-  us::Module *module = us::GetModuleContext()->GetModule();
-  us::ModuleResource resource = module->GetResource("RegionGrowing_48x48.png");
-  return resource;
-}
-
-void mitk::AdaptiveRegionGrowingTool::Activated()
-{
-  Superclass::Activated();
-
-  if (!GetDataStorage()->Exists(m_PointSetNode))
-    GetDataStorage()->Add(m_PointSetNode, GetWorkingData());
-  m_SeedPointInteractor = mitk::SinglePointDataInteractor::New();
-  m_SeedPointInteractor->LoadStateMachine("PointSet.xml");
-  m_SeedPointInteractor->SetEventConfig("PointSetConfig.xml");
-  m_SeedPointInteractor->SetDataNode(m_PointSetNode);
-}
-
-void mitk::AdaptiveRegionGrowingTool::Deactivated()
-{
-  m_PointSet->Clear();
-  GetDataStorage()->Remove(m_PointSetNode);
-
-  Superclass::Deactivated();
-}
-
-void mitk::AdaptiveRegionGrowingTool::ConfirmSegmentation()
-{
-  this->GetToolManager()->ActivateTool(-1);
-}
-
-mitk::DataNode *mitk::AdaptiveRegionGrowingTool::GetReferenceData()
-{
-  return this->GetToolManager()->GetReferenceData(0);
-}
-
-mitk::DataStorage *mitk::AdaptiveRegionGrowingTool::GetDataStorage()
-{
-  return this->GetToolManager()->GetDataStorage();
-}
-
-mitk::DataNode *mitk::AdaptiveRegionGrowingTool::GetWorkingData()
-{
-  return this->GetToolManager()->GetWorkingData(0);
-}
-
-mitk::DataNode::Pointer mitk::AdaptiveRegionGrowingTool::GetPointSetNode()
-{
-  return m_PointSetNode;
-}
diff --git a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.h b/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.h
deleted file mode 100644
index 7924978442..0000000000
--- a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#ifndef mitkAdaptiveRegionGrowingTool_h_Included
-#define mitkAdaptiveRegionGrowingTool_h_Included
-
-#include "mitkAutoSegmentationTool.h"
-#include "mitkCommon.h"
-#include "mitkDataStorage.h"
-#include "mitkPointSet.h"
-#include "mitkSinglePointDataInteractor.h"
-#include <MitkSegmentationExports.h>
-
-namespace us
-{
-  class ModuleResource;
-}
-
-namespace mitk
-{
-  /**
-  \brief Dummy Tool for AdaptiveRegionGrowingToolGUI to get Tool functionality for AdaptiveRegionGrowing.
-  The actual logic is implemented in QmitkAdaptiveRegionGrowingToolGUI.
-
-  \ingroup ToolManagerEtAl
-  \sa mitk::Tool
-  \sa QmitkInteractiveSegmentation
-
-  */
-  class MITKSEGMENTATION_EXPORT AdaptiveRegionGrowingTool : public AutoSegmentationTool
-  {
-  public:
-    /**
-     * @brief mitkClassMacro
-     */
-    mitkClassMacro(AdaptiveRegionGrowingTool, AutoSegmentationTool);
-    itkFactorylessNewMacro(Self);
-    itkCloneMacro(Self);
-
-    bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
-
-    /**
-     * @brief Get XPM
-     * @return nullptr
-     */
-    const char **GetXPM() const override;
-
-    /**
-     * @brief Get name
-     * @return name of the Tool
-     */
-    const char *GetName() const override;
-
-    /**
-     * @brief Get icon resource
-     * @return the resource Object of the Icon
-     */
-    us::ModuleResource GetIconResource() const override;
-
-    /**
-     * @brief Adds interactor for the seedpoint and creates a seedpoint if neccessary.
-     *
-     *
-     */
-    void Activated() override;
-
-    /**
-     * @brief Removes all set points and interactors.
-     *
-     *
-     */
-    void Deactivated() override;
-
-    /**
-     * @brief get pointset node
-     * @return the point set node
-     */
-    virtual DataNode::Pointer GetPointSetNode();
-
-    /**
-     * @brief get reference data
-     * @return the current reference data.
-     */
-    mitk::DataNode *GetReferenceData();
-
-    /**
-     * @brief Get working data
-     * @return a list of all working data.
-     */
-    mitk::DataNode *GetWorkingData();
-
-    /**
-     * @brief Get datastorage
-     * @return the current data storage.
-     */
-    mitk::DataStorage *GetDataStorage();
-
-    void ConfirmSegmentation();
-
-  protected:
-    /**
-     * @brief constructor
-     */
-    AdaptiveRegionGrowingTool(); // purposely hidden
-
-    /**
-     * @brief destructor
-     */
-    ~AdaptiveRegionGrowingTool() override;
-
-  private:
-    PointSet::Pointer m_PointSet;
-    SinglePointDataInteractor::Pointer m_SeedPointInteractor;
-    DataNode::Pointer m_PointSetNode;
-  };
-
-} // namespace
-
-#endif
diff --git a/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.cpp b/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.cpp
deleted file mode 100644
index 903be794ef..0000000000
--- a/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-// MITK
-#include "mitkAutoMLSegmentationWithPreviewTool.h"
-#include "mitkImageAccessByItk.h"
-#include "mitkToolManager.h"
-#include <mitkITKImageImport.h>
-#include <mitkImageCast.h>
-#include <mitkLevelWindowProperty.h>
-#include <mitkLookupTableProperty.h>
-#include <mitkRenderingModeProperty.h>
-#include <mitkSliceNavigationController.h>
-#include <mitkImageStatisticsHolder.h>
-
-// ITK
-#include <itkBinaryThresholdImageFilter.h>
-#include <itkOrImageFilter.h>
-
-mitk::AutoMLSegmentationWithPreviewTool::AutoMLSegmentationWithPreviewTool() : AutoSegmentationWithPreviewTool(true)
-{
-}
-
-void mitk::AutoMLSegmentationWithPreviewTool::SetSelectedLabels(const SelectedLabelVectorType& regions)
-{
-  if (m_SelectedLabels != regions)
-  {
-    m_SelectedLabels = regions;
-    //Note: we do not call this->Modified() on puprose. Reason: changing the
-    //selected regions should not force to run otsu filter in DoUpdatePreview due to changed MTime.
-  }
-}
-
-const mitk::LabelSetImage* mitk::AutoMLSegmentationWithPreviewTool::GetMLPreview() const
-{
-  if (m_MLPreviewNode.IsNotNull())
-  {
-    const auto mlPreviewImage = dynamic_cast<const LabelSetImage*>(this->m_MLPreviewNode->GetData());
-    return mlPreviewImage;
-  }
-
-  return nullptr;
-}
-
-mitk::AutoMLSegmentationWithPreviewTool::SelectedLabelVectorType mitk::AutoMLSegmentationWithPreviewTool::GetSelectedLabels() const
-{
-  return this->m_SelectedLabels;
-}
-
-void mitk::AutoMLSegmentationWithPreviewTool::Activated()
-{
-  Superclass::Activated();
-
-  m_SelectedLabels = {};
-
-  m_MLPreviewNode = mitk::DataNode::New();
-  m_MLPreviewNode->SetProperty("name", StringProperty::New(std::string(this->GetName()) + "ML preview"));
-  m_MLPreviewNode->SetProperty("helper object", BoolProperty::New(true));
-  m_MLPreviewNode->SetVisibility(true);
-  m_MLPreviewNode->SetOpacity(1.0);
-
-  this->GetToolManager()->GetDataStorage()->Add(m_MLPreviewNode);
-}
-
-void mitk::AutoMLSegmentationWithPreviewTool::Deactivated()
-{
-  this->GetToolManager()->GetDataStorage()->Remove(m_MLPreviewNode);
-  m_MLPreviewNode = nullptr;
-
-  Superclass::Deactivated();
-}
-
-void mitk::AutoMLSegmentationWithPreviewTool::UpdateCleanUp()
-{
-  if (m_MLPreviewNode.IsNotNull())
-    m_MLPreviewNode->SetVisibility(m_SelectedLabels.empty());
-
-  if (nullptr != this->GetPreviewSegmentationNode())
-    this->GetPreviewSegmentationNode()->SetVisibility(!m_SelectedLabels.empty());
-
-  if (m_SelectedLabels.empty())
-  {
-    this->ResetPreviewContent();
-  }
-}
-
-void mitk::AutoMLSegmentationWithPreviewTool::SetNodeProperties(LabelSetImage::Pointer newMLPreview)
-{
-  if (newMLPreview.IsNotNull())
-    {
-      this->m_MLPreviewNode->SetData(newMLPreview);
-      this->m_MLPreviewNode->SetProperty("binary", mitk::BoolProperty::New(false));
-      mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
-      renderingMode->SetValue(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR);
-      this->m_MLPreviewNode->SetProperty("Image Rendering.Mode", renderingMode);
-      mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
-      mitk::LookupTableProperty::Pointer prop = mitk::LookupTableProperty::New(lut);
-      vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
-      lookupTable->SetHueRange(1.0, 0.0);
-      lookupTable->SetSaturationRange(1.0, 1.0);
-      lookupTable->SetValueRange(1.0, 1.0);
-      lookupTable->SetTableRange(-1.0, 1.0);
-      lookupTable->Build();
-      lut->SetVtkLookupTable(lookupTable);
-      prop->SetLookupTable(lut);
-      this->m_MLPreviewNode->SetProperty("LookupTable", prop);
-      mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
-      mitk::LevelWindow levelwindow;
-      levelwindow.SetRangeMinMax(0, newMLPreview->GetStatistics()->GetScalarValueMax());
-      levWinProp->SetLevelWindow(levelwindow);
-      this->m_MLPreviewNode->SetProperty("levelwindow", levWinProp);
-    }
-}
-
-void mitk::AutoMLSegmentationWithPreviewTool::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, Image* previewImage, TimeStepType timeStep)
-{
-  const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
-
-  if (nullptr == m_MLPreviewNode->GetData()
-      || this->GetMTime() > m_MLPreviewNode->GetData()->GetMTime()
-      || this->m_LastMLTimeStep != timeStep //this covers the case where dynamic
-                                            //segmentations have to compute a preview
-                                            //for all time steps on confirmation
-      || this->GetLastTimePointOfUpdate() != timePoint //this ensures that static seg
-                                                       //previews work with dynamic images
-                                                       //with avoiding unnecessary other computations
-     )
-  {
-    if (nullptr == inputAtTimeStep)
-    {
-      MITK_WARN << "Cannot run segementation. Currently selected input image is not set.";
-      return;
-    }
-
-    this->m_LastMLTimeStep = timeStep;
-
-    auto newMLPreview = ComputeMLPreview(inputAtTimeStep, timeStep);
-    this->SetNodeProperties(newMLPreview);
-  }
-
-  if (!m_SelectedLabels.empty())
-  {
-    const auto mlPreviewImage = this->GetMLPreview();
-    if (nullptr != mlPreviewImage)
-    {
-      AccessByItk_n(mlPreviewImage, CalculateMergedSimplePreview, (previewImage, timeStep));
-    }
-  }
-}
-
-template <typename TPixel, unsigned int VImageDimension>
-void mitk::AutoMLSegmentationWithPreviewTool::CalculateMergedSimplePreview(const itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image* segmentation, unsigned int timeStep)
-{
-  typedef itk::Image<TPixel, VImageDimension> InputImageType;
-  typedef itk::Image<mitk::Tool::DefaultSegmentationDataType, VImageDimension> OutputImageType;
-
-  typedef itk::BinaryThresholdImageFilter<InputImageType, OutputImageType> FilterType;
-
-  typename FilterType::Pointer filter = FilterType::New();
-
-  // InputImageType::Pointer itkImage;
-  typename OutputImageType::Pointer itkBinaryResultImage;
-
-  filter->SetInput(itkImage);
-  filter->SetLowerThreshold(m_SelectedLabels[0]);
-  filter->SetUpperThreshold(m_SelectedLabels[0]);
-  filter->SetInsideValue(this->GetUserDefinedActiveLabel());
-  filter->SetOutsideValue(0);
-  filter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
-  filter->Update();
-  itkBinaryResultImage = filter->GetOutput();
-  itkBinaryResultImage->DisconnectPipeline();
-
-  // if more than one region id is used compute the union of all given binary regions
-  for (const auto labelID : m_SelectedLabels)
-  {
-    if (labelID != m_SelectedLabels[0])
-    {
-      filter->SetLowerThreshold(labelID);
-      filter->SetUpperThreshold(labelID);
-      filter->SetInsideValue(this->GetUserDefinedActiveLabel());
-      filter->SetOutsideValue(0);
-      filter->Update();
-
-      typename OutputImageType::Pointer tempImage = filter->GetOutput();
-
-      typename itk::OrImageFilter<OutputImageType, OutputImageType>::Pointer orFilter =
-        itk::OrImageFilter<OutputImageType, OutputImageType>::New();
-      orFilter->SetInput1(tempImage);
-      orFilter->SetInput2(itkBinaryResultImage);
-      orFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
-
-      orFilter->UpdateLargestPossibleRegion();
-      itkBinaryResultImage = orFilter->GetOutput();
-    }
-  }
-  //----------------------------------------------------------------------------------------------------
-
-  segmentation->SetVolume((void*)(itkBinaryResultImage->GetPixelContainer()->GetBufferPointer()), timeStep);
-}
diff --git a/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.h b/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.h
deleted file mode 100644
index 60921765c6..0000000000
--- a/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-#ifndef MITK_AUTO_ML_SEGMENTATION_WITH_PREVIEW_TOOL_H
-#define MITK_AUTO_ML_SEGMENTATION_WITH_PREVIEW_TOOL_H
-
-#include "mitkAutoSegmentationWithPreviewTool.h"
-#include "mitkDataNode.h"
-#include "mitkLabelSetImage.h"
-
-#include <MitkSegmentationExports.h>
-
-namespace mitk
-{
-  /**
-  \brief Base class for any auto segmentation tool that provides a preview of the new segmentation and generates
-  segmentations with multiple labels.
-
-  This tool class implements the basic logic to handle previews of multi label segmentations and
-  to allow to pick arbitrary labels as selected and merge them to a single segmentation to store this
-  segmentation as confirmed segmentation.
-
-  \ingroup ToolManagerEtAl
-  \sa mitk::Tool
-  \sa QmitkInteractiveSegmentation
-  */
-  class MITKSEGMENTATION_EXPORT AutoMLSegmentationWithPreviewTool : public AutoSegmentationWithPreviewTool
-  {
-  public:
-    mitkClassMacro(AutoMLSegmentationWithPreviewTool, AutoSegmentationWithPreviewTool);
-
-    void Activated() override;
-    void Deactivated() override;
-
-    using SelectedLabelVectorType = std::vector<Label::PixelType>;
-    void SetSelectedLabels(const SelectedLabelVectorType& regions);
-    SelectedLabelVectorType GetSelectedLabels() const;
-
-    const LabelSetImage* GetMLPreview() const;
-
-  protected:
-    AutoMLSegmentationWithPreviewTool();
-    ~AutoMLSegmentationWithPreviewTool() = default;
-
-    void UpdateCleanUp() override;
-    void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
-    virtual void SetNodeProperties(LabelSetImage::Pointer);
-    /** Function to generate the new multi lable preview for a given time step input image.
-     * The function must be implemented by derived tools.
-     * This function is called by DoUpdatePreview if needed.
-     * Reasons are:
-     * - ML preview does not exist
-     * - Modify time of tools is newer then of ML preview
-     * - ML preview was not generated for the current selected timestep of input image or for the current selected timepoint.*/
-    virtual LabelSetImage::Pointer ComputeMLPreview(const Image* inputAtTimeStep, TimeStepType timeStep) = 0;
-
-  private:
-    /** Function to generate a simple (single lable) preview by merging all labels of the ML preview that are selected and
-     * copies that single label preview to the passed previewImage.
-     * This function is called by DoUpdatePreview if needed.
-     * @param mlPreviewImage Multi label preview that is the source.
-     * @param previewImage Pointer to the single label preview image that should receive the merged selected labels.
-     * @timeStep Time step of the previewImage that should be filled.*/
-    template <typename TPixel, unsigned int VImageDimension>
-    void CalculateMergedSimplePreview(const itk::Image<TPixel, VImageDimension>* mlImage, mitk::Image* segmentation, unsigned int timeStep);
-
-    SelectedLabelVectorType m_SelectedLabels = {};
-
-    // holds the multilabel result as a preview image
-    mitk::DataNode::Pointer m_MLPreviewNode;
-    TimeStepType m_LastMLTimeStep = 0;
-  };
-}
-#endif
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
deleted file mode 100644
index 03813c8731..0000000000
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include "mitkAutoSegmentationTool.h"
-#include "mitkImage.h"
-#include "mitkToolManager.h"
-#include <mitkImageTimeSelector.h>
-#include <mitkLabelSetImageHelper.h>
-
-mitk::AutoSegmentationTool::AutoSegmentationTool() : Tool("dummy"), m_OverwriteExistingSegmentation(false)
-{
-}
-
-mitk::AutoSegmentationTool::AutoSegmentationTool(const char* interactorType, const us::Module* interactorModule) : Tool(interactorType, interactorModule), m_OverwriteExistingSegmentation(false)
-{
-}
-
-mitk::AutoSegmentationTool::~AutoSegmentationTool()
-{
-}
-
-void mitk::AutoSegmentationTool::Activated()
-{
-  Superclass::Activated();
-
-  m_NoneOverwriteTargetSegmentationNode = nullptr;
-}
-
-void mitk::AutoSegmentationTool::Deactivated()
-{
-  m_NoneOverwriteTargetSegmentationNode = nullptr;
-
-  Superclass::Deactivated();
-}
-
-const char *mitk::AutoSegmentationTool::GetGroup() const
-{
-  return "autoSegmentation";
-}
-
-mitk::Image::ConstPointer mitk::AutoSegmentationTool::GetImageByTimeStep(const mitk::Image* image, unsigned int timestep)
-{
-  if (nullptr == image)
-    return image;
-
-  if (image->GetDimension() != 4)
-    return image;
-
-  mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
-
-  imageTimeSelector->SetInput(image);
-  imageTimeSelector->SetTimeNr(static_cast<int>(timestep));
-
-  imageTimeSelector->UpdateLargestPossibleRegion();
-
-  return imageTimeSelector->GetOutput();
-}
-
-mitk::Image::Pointer mitk::AutoSegmentationTool::GetImageByTimeStep(mitk::Image* image, unsigned int timestep)
-{
-  if (nullptr == image)
-    return image;
-
-  if (image->GetDimension() != 4)
-    return image;
-
-  mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
-
-  imageTimeSelector->SetInput(image);
-  imageTimeSelector->SetTimeNr(static_cast<int>(timestep));
-
-  imageTimeSelector->UpdateLargestPossibleRegion();
-
-  return imageTimeSelector->GetOutput();
-}
-
-mitk::Image::ConstPointer mitk::AutoSegmentationTool::GetImageByTimePoint(const mitk::Image* image, TimePointType timePoint)
-{
-  if (nullptr == image)
-    return image;
-
-  if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
-    return nullptr;
-
-  return AutoSegmentationTool::GetImageByTimeStep(image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint));
-}
-
-void mitk::AutoSegmentationTool::SetOverwriteExistingSegmentation(bool overwrite)
-{
-  if (m_OverwriteExistingSegmentation != overwrite)
-  {
-    m_OverwriteExistingSegmentation = overwrite;
-    m_NoneOverwriteTargetSegmentationNode = nullptr;
-  }
-}
-
-std::string mitk::AutoSegmentationTool::GetCurrentSegmentationName()
-{
-  if (this->GetToolManager()->GetWorkingData(0))
-    return this->GetToolManager()->GetWorkingData(0)->GetName();
-  else
-    return "";
-}
-
-mitk::DataNode *mitk::AutoSegmentationTool::GetTargetSegmentationNode() const
-{
-  mitk::DataNode::Pointer segmentationNode = this->GetToolManager()->GetWorkingData(0);
-  if (!m_OverwriteExistingSegmentation)
-  {
-    if (m_NoneOverwriteTargetSegmentationNode.IsNull())
-    {
-      mitk::DataNode::Pointer refNode = this->GetToolManager()->GetReferenceData(0);
-      if (refNode.IsNull())
-      {
-        // TODO create and use segmentation exceptions instead!!
-        MITK_ERROR << "No valid reference data!";
-        return nullptr;
-      }
-      std::string nodename = refNode->GetName() + "_" + this->GetName();
-
-      const auto labelSetImage = dynamic_cast<mitk::LabelSetImage*>(segmentationNode->GetData());
-      if (nullptr == labelSetImage)
-      {
-        //TODO: this part of the if statement is old legacy code and should be removed.
-        //Keept because I didn't want to break/rework to many things before
-        //the release 2022.04. Should be removed when the seg tool classes are streamlined and the
-        //multi data structure is the only one used in seg APIs and code.
-
-        mitk::Color color;
-        color.SetRed(1);
-        color.SetBlue(0);
-        color.SetGreen(0);
-        //create a new segmentation node based on the current segmentation as template
-        m_NoneOverwriteTargetSegmentationNode = CreateEmptySegmentationNode(dynamic_cast<mitk::Image*>(segmentationNode->GetData()), nodename, color);
-      }
-      else
-      {
-        auto clonedSegmentation = labelSetImage->Clone();
-        m_NoneOverwriteTargetSegmentationNode = LabelSetImageHelper::CreateEmptySegmentationNode(nodename);
-        m_NoneOverwriteTargetSegmentationNode->SetData(clonedSegmentation);
-      }
-    }
-    segmentationNode = m_NoneOverwriteTargetSegmentationNode;
-  }
-  return segmentationNode;
-}
-
-void mitk::AutoSegmentationTool::EnsureTargetSegmentationNodeInDataStorage() const
-{
-  auto targetNode = this->GetTargetSegmentationNode();
-  if (!this->GetToolManager()->GetDataStorage()->Exists(targetNode))
-  {
-    this->GetToolManager()->GetDataStorage()->Add(targetNode, this->GetToolManager()->GetReferenceData(0));
-  }
-}
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
deleted file mode 100644
index 8665208340..0000000000
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#ifndef mitkAutoSegmentationTool_h_Included
-#define mitkAutoSegmentationTool_h_Included
-
-#include "mitkCommon.h"
-#include "mitkTool.h"
-#include <MitkSegmentationExports.h>
-
-namespace mitk
-{
-  class Image;
-
-  /**
-    \brief Superclass for tool that create a new segmentation without user interaction in render windows
-
-    This class is undocumented. Ask the creator ($Author$) to supply useful comments.
-  */
-  class MITKSEGMENTATION_EXPORT AutoSegmentationTool : public Tool
-  {
-  public:
-    mitkClassMacro(AutoSegmentationTool, Tool);
-
-    void Activated() override;
-    void Deactivated() override;
-
-    /** This function controls wether a confirmed segmentation should replace the old
-    * segmentation/working node (true) or if it should be stored as new and additional
-    * node (false).
-    */
-    void SetOverwriteExistingSegmentation(bool overwrite);
-
-    /**
-     * @brief Gets the name of the currently selected segmentation node
-     * @return the name of the segmentation node or an empty string if
-     *         none is selected
-     */
-    std::string GetCurrentSegmentationName();
-
-    /**
-     * @brief Depending on the selected mode either returns the currently selected segmentation node
-     *        or (if overwrite mode is false) creates a new one from the selected reference data.
-     * @remark Please keep in mind that new created nodes are not automatically added to the data storage.
-     * Derived tools can call EnsureTargetSegmentationNodeInDataStorage to ensure it as soon as it is clear
-     * that the target segmentation node will be/is confirmed.
-     * @return a mitk::DataNode which contains a segmentation image
-     */
-    virtual DataNode *GetTargetSegmentationNode() const;
-
-  protected:
-    AutoSegmentationTool(); // purposely hidden
-    AutoSegmentationTool(const char* interactorType, const us::Module* interactorModule = nullptr); // purposely hidden
-    ~AutoSegmentationTool() override;
-
-    const char *GetGroup() const override;
-
-    /** Helper that extracts the image for the passed timestep, if the image has multiple time steps.*/
-    static Image::ConstPointer GetImageByTimeStep(const Image* image, unsigned int timestep);
-    /** Helper that extracts the image for the passed timestep, if the image has multiple time steps.*/
-    static Image::Pointer GetImageByTimeStep(Image* image, unsigned int timestep);
-    /** Helper that extracts the image for the passed time point, if the image has multiple time steps.*/
-    static Image::ConstPointer GetImageByTimePoint(const Image* image, TimePointType timePoint);
-
-    void EnsureTargetSegmentationNodeInDataStorage() const;
-
-    bool m_OverwriteExistingSegmentation;
-
-  private:
-    /**Contains the node returned by GetTargetSementationNode if m_OverwriteExistingSegmentation == false. Then
-    * GetTargetSegmentation generates a new target segmentation node.*/
-    mutable DataNode::Pointer m_NoneOverwriteTargetSegmentationNode;
-  };
-
-} // namespace
-
-#endif
diff --git a/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.cpp b/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.cpp
index cbc5a650cb..baad32e9c2 100644
--- a/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.cpp
@@ -1,122 +1,122 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkBinaryThresholdBaseTool.h"
 
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkImageStatisticsHolder.h"
 #include "mitkLabelSetImage.h"
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkImageRegionIterator.h>
 
 mitk::BinaryThresholdBaseTool::BinaryThresholdBaseTool()
   : m_SensibleMinimumThreshold(-100),
     m_SensibleMaximumThreshold(+100),
     m_LowerThreshold(1),
     m_UpperThreshold(1)
 {
 }
 
 mitk::BinaryThresholdBaseTool::~BinaryThresholdBaseTool()
 {
 }
 
 void mitk::BinaryThresholdBaseTool::SetThresholdValues(double lower, double upper)
 {
   /* If value is not in the min/max range, do nothing. In that case, this
      method will be called again with a proper value right after. The only
      known case where this happens is with an [0.0, 1.0[ image, where value
      could be an epsilon greater than the max. */
   if (lower < m_SensibleMinimumThreshold
     || lower > m_SensibleMaximumThreshold
     || upper < m_SensibleMinimumThreshold
     || upper > m_SensibleMaximumThreshold)
   {
     return;
   }
 
   m_LowerThreshold = lower;
   m_UpperThreshold = upper;
 
   if (nullptr != this->GetPreviewSegmentation())
   {
     UpdatePreview();
   }
 }
 
 void mitk::BinaryThresholdBaseTool::InitiateToolByInput()
 {
   const auto referenceImage = this->GetReferenceData();
   if (nullptr != referenceImage)
   {
     m_SensibleMinimumThreshold = std::numeric_limits<ScalarType>::max();
     m_SensibleMaximumThreshold = std::numeric_limits<ScalarType>::lowest();
     Image::StatisticsHolderPointer statistics = referenceImage->GetStatistics();
     for (unsigned int ts = 0; ts < referenceImage->GetTimeSteps(); ++ts)
     {
       m_SensibleMinimumThreshold = std::min(m_SensibleMinimumThreshold, static_cast<double>(statistics->GetScalarValueMin()));
       m_SensibleMaximumThreshold = std::max(m_SensibleMaximumThreshold, static_cast<double>(statistics->GetScalarValueMax()));
     }
 
     if (m_LockedUpperThreshold)
     {
       m_LowerThreshold = (m_SensibleMaximumThreshold + m_SensibleMinimumThreshold) / 2.0;
       m_UpperThreshold = m_SensibleMaximumThreshold;
     }
     else
     {
       double range = m_SensibleMaximumThreshold - m_SensibleMinimumThreshold;
       m_LowerThreshold = m_SensibleMinimumThreshold + range / 3.0;
       m_UpperThreshold = m_SensibleMinimumThreshold + 2 * range / 3.0;
     }
 
     bool isFloatImage = false;
     if ((referenceImage->GetPixelType().GetPixelType() == itk::IOPixelEnum::SCALAR) &&
         (referenceImage->GetPixelType().GetComponentType() == itk::IOComponentEnum::FLOAT ||
           referenceImage->GetPixelType().GetComponentType() == itk::IOComponentEnum::DOUBLE))
     {
       isFloatImage = true;
     }
 
     IntervalBordersChanged.Send(m_SensibleMinimumThreshold, m_SensibleMaximumThreshold, isFloatImage);
     ThresholdingValuesChanged.Send(m_LowerThreshold, m_UpperThreshold);
   }
 }
 
-void mitk::BinaryThresholdBaseTool::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, Image* previewImage, TimeStepType timeStep)
+void mitk::BinaryThresholdBaseTool::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, LabelSetImage* previewImage, TimeStepType timeStep)
 {
   if (nullptr != inputAtTimeStep && nullptr != previewImage)
   {
     AccessByItk_n(inputAtTimeStep, ITKThresholding, (previewImage, timeStep));
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::BinaryThresholdBaseTool::ITKThresholding(const itk::Image<TPixel, VImageDimension>* inputImage,
                                                     Image* segmentation,
                                                     unsigned int timeStep)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<Tool::DefaultSegmentationDataType, VImageDimension> SegmentationType;
   typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
 
   typename ThresholdFilterType::Pointer filter = ThresholdFilterType::New();
   filter->SetInput(inputImage);
   filter->SetLowerThreshold(m_LowerThreshold);
   filter->SetUpperThreshold(m_UpperThreshold);
   filter->SetInsideValue(this->GetUserDefinedActiveLabel());
   filter->SetOutsideValue(0);
   filter->Update();
 
   segmentation->SetVolume((void *)(filter->GetOutput()->GetPixelContainer()->GetBufferPointer()), timeStep);
 }
diff --git a/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h b/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h
index e7aa8fbddf..c283490bfc 100644
--- a/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h
+++ b/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h
@@ -1,77 +1,77 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkBinaryThresholdBaseTool_h_Included
 #define mitkBinaryThresholdBaseTool_h_Included
 
 #include <MitkSegmentationExports.h>
 
-#include <mitkAutoSegmentationWithPreviewTool.h>
+#include <mitkSegWithPreviewTool.h>
 
 #include <mitkCommon.h>
 #include <mitkDataNode.h>
 
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkImage.h>
 
 namespace mitk
 {
   /**
   \brief Base class for binary threshold tools.
 
   \ingroup ToolManagerEtAl
   \sa mitk::Tool
   \sa QmitkInteractiveSegmentation
   */
-  class MITKSEGMENTATION_EXPORT BinaryThresholdBaseTool : public AutoSegmentationWithPreviewTool
+  class MITKSEGMENTATION_EXPORT BinaryThresholdBaseTool : public SegWithPreviewTool
   {
   public:
     Message3<double, double, bool> IntervalBordersChanged;
     Message2<ScalarType, ScalarType> ThresholdingValuesChanged;
 
-    mitkClassMacro(BinaryThresholdBaseTool, AutoSegmentationWithPreviewTool);
+    mitkClassMacro(BinaryThresholdBaseTool, SegWithPreviewTool);
 
     virtual void SetThresholdValues(double lower, double upper);
 
   protected:
     BinaryThresholdBaseTool(); // purposely hidden
     ~BinaryThresholdBaseTool() override;
 
     itkSetMacro(LockedUpperThreshold, bool);
     itkGetMacro(LockedUpperThreshold, bool);
     itkBooleanMacro(LockedUpperThreshold);
 
     itkGetMacro(SensibleMinimumThreshold, ScalarType);
     itkGetMacro(SensibleMaximumThreshold, ScalarType);
 
     void InitiateToolByInput() override;
-    void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
+    void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep) override;
 
     template <typename TPixel, unsigned int VImageDimension>
     void ITKThresholding(const itk::Image<TPixel, VImageDimension>* inputImage,
       Image* segmentation, unsigned int timeStep);
 
   private:
     ScalarType m_SensibleMinimumThreshold;
     ScalarType m_SensibleMaximumThreshold;
     ScalarType m_LowerThreshold;
     ScalarType m_UpperThreshold;
 
     /** Indicates if the tool should behave like a single threshold tool (true)
       or like a upper/lower threshold tool (false)*/
     bool m_LockedUpperThreshold = false;
 
   };
 
 } // namespace
 
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp b/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp
index ec02f6a346..a7ce47fcec 100644
--- a/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp
+++ b/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp
@@ -1,86 +1,87 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // MITK
 #include "mitkOtsuTool3D.h"
 #include "mitkOtsuSegmentationFilter.h"
 
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 #include <mitkImageStatisticsHolder.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, OtsuTool3D, "Otsu Segmentation");
 }
 
 void mitk::OtsuTool3D::Activated()
 {
   Superclass::Activated();
 
   m_NumberOfBins = 128;
   m_NumberOfRegions = 2;
   m_UseValley = false;
+  this->SetLabelTransferMode(LabelTransferMode::AllLabels);
 }
 
 const char **mitk::OtsuTool3D::GetXPM() const
 {
   return nullptr;
 }
 
 us::ModuleResource mitk::OtsuTool3D::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Otsu_48x48.png");
   return resource;
 }
 
 const char* mitk::OtsuTool3D::GetName() const
 {
   return "Otsu";
 }
 
-mitk::LabelSetImage::Pointer mitk::OtsuTool3D::ComputeMLPreview(const Image* inputAtTimeStep, TimeStepType /*timeStep*/)
+void mitk::OtsuTool3D::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, LabelSetImage* previewImage, TimeStepType timeStep)
 {
   int numberOfThresholds = m_NumberOfRegions - 1;
 
   mitk::OtsuSegmentationFilter::Pointer otsuFilter = mitk::OtsuSegmentationFilter::New();
   otsuFilter->SetNumberOfThresholds(numberOfThresholds);
   otsuFilter->SetValleyEmphasis(m_UseValley);
   otsuFilter->SetNumberOfBins(m_NumberOfBins);
   otsuFilter->SetInput(inputAtTimeStep);
   otsuFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
 
   try
   {
     otsuFilter->Update();
   }
   catch (...)
   {
     mitkThrow() << "itkOtsuFilter error (image dimension must be in {2, 3} and image must not be RGB)";
   }
 
   auto otsuResultImage = mitk::LabelSetImage::New();
   otsuResultImage->InitializeByLabeledImage(otsuFilter->GetOutput());
-  return otsuResultImage;
+  TransferLabelSetImageContent(otsuResultImage, previewImage, timeStep);
 }
 
 unsigned int mitk::OtsuTool3D::GetMaxNumberOfBins() const
 {
   const auto min = this->GetReferenceData()->GetStatistics()->GetScalarValueMin();
   const auto max = this->GetReferenceData()->GetStatistics()->GetScalarValueMaxNoRecompute();
   return static_cast<unsigned int>(max - min) + 1;
 }
diff --git a/Modules/Segmentation/Interactions/mitkOtsuTool3D.h b/Modules/Segmentation/Interactions/mitkOtsuTool3D.h
index 3703b237a6..800d2f819f 100644
--- a/Modules/Segmentation/Interactions/mitkOtsuTool3D.h
+++ b/Modules/Segmentation/Interactions/mitkOtsuTool3D.h
@@ -1,64 +1,64 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #ifndef MITKOTSUTOOL3D_H
 #define MITKOTSUTOOL3D_H
 
-#include "mitkAutoMLSegmentationWithPreviewTool.h"
+#include "mitkSegWithPreviewTool.h"
 #include <MitkSegmentationExports.h>
 
 namespace us
 {
   class ModuleResource;
 }
 
 namespace mitk
 {
   class Image;
 
-  class MITKSEGMENTATION_EXPORT OtsuTool3D : public AutoMLSegmentationWithPreviewTool
+  class MITKSEGMENTATION_EXPORT OtsuTool3D : public SegWithPreviewTool
   {
   public:
-    mitkClassMacro(OtsuTool3D, AutoMLSegmentationWithPreviewTool);
+    mitkClassMacro(OtsuTool3D, SegWithPreviewTool);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     const char *GetName() const override;
     const char **GetXPM() const override;
     us::ModuleResource GetIconResource() const override;
 
     void Activated() override;
 
     itkSetMacro(NumberOfBins, unsigned int);
     itkGetConstMacro(NumberOfBins, unsigned int);
 
     itkSetMacro(NumberOfRegions, unsigned int);
     itkGetConstMacro(NumberOfRegions, unsigned int);
 
     itkSetMacro(UseValley, bool);
     itkGetConstMacro(UseValley, bool);
     itkBooleanMacro(UseValley);
 
     /**Returns the number of max bins based on the current input image.*/
     unsigned int GetMaxNumberOfBins() const;
 
   protected:
     OtsuTool3D() = default;
     ~OtsuTool3D() = default;
 
-    LabelSetImage::Pointer ComputeMLPreview(const Image* inputAtTimeStep, TimeStepType timeStep) override;
+    void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep) override;
 
     unsigned int m_NumberOfBins = 128;
     unsigned int m_NumberOfRegions = 2;
     bool m_UseValley = false;
   }; // class
 } // namespace
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkPickingTool.cpp b/Modules/Segmentation/Interactions/mitkPickingTool.cpp
index b45438f6e3..6f94213db6 100644
--- a/Modules/Segmentation/Interactions/mitkPickingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPickingTool.cpp
@@ -1,276 +1,276 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkPickingTool.h"
 
 #include "mitkProperties.h"
 #include "mitkToolManager.h"
 
 #include "mitkInteractionPositionEvent.h"
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkImageTimeSelector.h"
 
 #include <itkImage.h>
 #include <itkConnectedThresholdImageFilter.h>
 #include <itkOrImageFilter.h>
 #include <mitkLabelSetImage.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, PickingTool, "PickingTool");
 }
 
-mitk::PickingTool::PickingTool() : AutoSegmentationWithPreviewTool(false, "PressMoveReleaseAndPointSetting")
+mitk::PickingTool::PickingTool() : SegWithPreviewTool(false, "PressMoveReleaseAndPointSetting")
 {
   this->ResetsToEmptyPreviewOn();
 }
 
 mitk::PickingTool::~PickingTool()
 {
 }
 
 bool mitk::PickingTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
 {
   if (!Superclass::CanHandle(referenceData,workingData))
     return false;
 
   auto* image = dynamic_cast<const Image*>(referenceData);
 
   if (image == nullptr)
     return false;
 
   return true;
 }
 
 const char **mitk::PickingTool::GetXPM() const
 {
   return nullptr;
 }
 
 const char *mitk::PickingTool::GetName() const
 {
   return "Picking";
 }
 
 us::ModuleResource mitk::PickingTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Pick_48x48.png");
   return resource;
 }
 
 void mitk::PickingTool::Activated()
 {
   Superclass::Activated();
 
   m_PointSet = mitk::PointSet::New();
   //ensure that the seed points are visible for all timepoints.
   dynamic_cast<ProportionalTimeGeometry*>(m_PointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
 
   m_PointSetNode = mitk::DataNode::New();
   m_PointSetNode->SetData(m_PointSet);
   m_PointSetNode->SetName(std::string(this->GetName()) + "_PointSet");
   m_PointSetNode->SetBoolProperty("helper object", true);
   m_PointSetNode->SetColor(0.0, 1.0, 0.0);
   m_PointSetNode->SetVisibility(true);
 
   this->GetDataStorage()->Add(m_PointSetNode, this->GetToolManager()->GetWorkingData(0));
 }
 
 void mitk::PickingTool::Deactivated()
 {
   this->ClearSeeds();
 
   // remove from data storage and disable interaction
   GetDataStorage()->Remove(m_PointSetNode);
   m_PointSetNode = nullptr;
   m_PointSet = nullptr;
 
   Superclass::Deactivated();
 }
 
 void mitk::PickingTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION("ShiftSecondaryButtonPressed", OnAddPoint);
   CONNECT_FUNCTION("ShiftPrimaryButtonPressed", OnAddPoint);
   CONNECT_FUNCTION("DeletePoint", OnDelete);
 }
 
 void mitk::PickingTool::OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   if (!this->IsUpdating() && m_PointSet.IsNotNull())
   {
     const auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
 
     if (positionEvent != nullptr)
     {
       m_PointSet->InsertPoint(m_PointSet->GetSize(), positionEvent->GetPositionInWorld());
       this->UpdatePreview();
     }
   }
 }
 
 void mitk::PickingTool::OnDelete(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
 {
   if (!this->IsUpdating() && m_PointSet.IsNotNull())
   {
     // delete last seed point
     if (this->m_PointSet->GetSize() > 0)
     {
       m_PointSet->RemovePointAtEnd(0);
 
       this->UpdatePreview();
     }
   }
 }
 
 void mitk::PickingTool::ClearPicks()
 {
   this->ClearSeeds();
   this->UpdatePreview();
 }
 
 bool mitk::PickingTool::HasPicks() const
 {
   return this->m_PointSet.IsNotNull() && this->m_PointSet->GetSize()>0;
 }
 
 void mitk::PickingTool::ClearSeeds()
 {
   if (this->m_PointSet.IsNotNull())
   {
     // renew pointset
     this->m_PointSet = mitk::PointSet::New();
     //ensure that the seed points are visible for all timepoints.
     dynamic_cast<ProportionalTimeGeometry*>(m_PointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
     this->m_PointSetNode->SetData(this->m_PointSet);
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void DoITKRegionGrowing(const itk::Image<TPixel, VImageDimension>* oldSegImage,
   mitk::Image* segmentation,
   const mitk::PointSet* seedPoints,
   unsigned int timeStep, const mitk::BaseGeometry* inputGeometry, const mitk::Label::PixelType outputValue,
   const mitk::Label::PixelType backgroundValue,
   bool& emptyTimeStep)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
   typedef itk::Image<mitk::Label::PixelType, VImageDimension> OutputImageType;
   typedef typename InputImageType::IndexType IndexType;
   typedef itk::ConnectedThresholdImageFilter<InputImageType, OutputImageType> RegionGrowingFilterType;
 
   using IndexMapType = std::map < mitk::Label::PixelType, std::vector<IndexType> >;
 
   IndexMapType indexMap;
 
   // convert world coordinates to image indices
   for (auto pos = seedPoints->Begin(); pos != seedPoints->End(); ++pos)
   {
     IndexType seedIndex;
     inputGeometry->WorldToIndex(pos->Value(), seedIndex);
     const auto selectedLabel = oldSegImage->GetPixel(seedIndex);
 
     if (selectedLabel != backgroundValue)
     {
       indexMap[selectedLabel].push_back(seedIndex);
     }
   }
 
   typename OutputImageType::Pointer itkResultImage;
 
   try
   {
     bool first = true;
     typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
     regionGrower->SetInput(oldSegImage);
     regionGrower->SetReplaceValue(outputValue);
 
     for (const auto& [label, indeces] : indexMap)
     {
       // perform region growing in desired segmented region
       regionGrower->ClearSeeds();
       for (const auto& index : indeces)
       {
         regionGrower->AddSeed(index);
       }
 
       regionGrower->SetLower(label);
       regionGrower->SetUpper(label);
 
       regionGrower->Update();
 
       if (first)
       {
         itkResultImage = regionGrower->GetOutput();
       }
       else
       {
         typename itk::OrImageFilter<OutputImageType, OutputImageType>::Pointer orFilter =
           itk::OrImageFilter<OutputImageType, OutputImageType>::New();
         orFilter->SetInput1(regionGrower->GetOutput());
         orFilter->SetInput2(itkResultImage);
 
         orFilter->Update();
         itkResultImage = orFilter->GetOutput();
       }
       first = false;
       itkResultImage->DisconnectPipeline();
     }
   }
   catch (const itk::ExceptionObject&)
   {
     return; // can't work
   }
   catch (...)
   {
     return;
   }
 
   if (itkResultImage.IsNotNull())
   {
     segmentation->SetVolume((void*)(itkResultImage->GetPixelContainer()->GetBufferPointer()),timeStep);
   }
   emptyTimeStep = itkResultImage.IsNull();
 
 }
 
-void mitk::PickingTool::DoUpdatePreview(const Image* /*inputAtTimeStep*/, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep)
+void mitk::PickingTool::DoUpdatePreview(const Image* /*inputAtTimeStep*/, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep)
 {
   if (nullptr != oldSegAtTimeStep && nullptr != previewImage && m_PointSet.IsNotNull())
   {
     bool emptyTimeStep = true;
     if (this->HasPicks())
     {
       Label::PixelType backgroundValue = 0;
       auto labelSetImage = dynamic_cast<const LabelSetImage*>(oldSegAtTimeStep);
       if (nullptr != labelSetImage)
       {
         backgroundValue = labelSetImage->GetExteriorLabel()->GetValue();
       }
       AccessFixedDimensionByItk_n(oldSegAtTimeStep, DoITKRegionGrowing, 3, (previewImage, this->m_PointSet, timeStep, oldSegAtTimeStep->GetGeometry(), this->GetUserDefinedActiveLabel(), backgroundValue, emptyTimeStep));
     }
     if (emptyTimeStep)
     {
       this->ResetPreviewContentAtTimeStep(timeStep);
     }
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitkPickingTool.h b/Modules/Segmentation/Interactions/mitkPickingTool.h
index dd092dcf28..c129eb6087 100644
--- a/Modules/Segmentation/Interactions/mitkPickingTool.h
+++ b/Modules/Segmentation/Interactions/mitkPickingTool.h
@@ -1,85 +1,85 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkPickingTool_h_Included
 #define mitkPickingTool_h_Included
 
-#include "mitkAutoSegmentationWithPreviewTool.h"
+#include "mitkSegWithPreviewTool.h"
 #include "mitkPointSet.h"
 
 #include <MitkSegmentationExports.h>
 
 namespace us
 {
   class ModuleResource;
 }
 
 namespace mitk
 {
   /**
   \brief Extracts a single region from a segmentation image and creates a new image with same geometry of the input
   image.
 
   The region is extracted in 3D space. This is done by performing region growing within the desired region.
   Use shift click to add the seed point.
 
   \ingroup ToolManagerEtAl
   \sa mitk::Tool
   \sa QmitkInteractiveSegmentation
 
   */
-  class MITKSEGMENTATION_EXPORT PickingTool : public AutoSegmentationWithPreviewTool
+  class MITKSEGMENTATION_EXPORT PickingTool : public SegWithPreviewTool
   {
   public:
-    mitkClassMacro(PickingTool, AutoSegmentationWithPreviewTool);
+    mitkClassMacro(PickingTool, SegWithPreviewTool);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     const char **GetXPM() const override;
     const char *GetName() const override;
     us::ModuleResource GetIconResource() const override;
 
     bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
 
     void Activated() override;
     void Deactivated() override;
 
     /**Clears all picks and updates the preview.*/
     void ClearPicks();
 
     bool HasPicks() const;
 
   protected:
     PickingTool(); // purposely hidden
     ~PickingTool() override;
 
     void ConnectActionsAndFunctions() override;
 
     /// \brief Add point action of StateMachine pattern
     virtual void OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent);
 
     /// \brief Delete action of StateMachine pattern
     virtual void OnDelete(StateMachineAction*, InteractionEvent* interactionEvent);
 
     /// \brief Clear all seed points.
     void ClearSeeds();
 
-    void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
+    void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep) override;
 
     // seed point
     PointSet::Pointer m_PointSet;
     DataNode::Pointer m_PointSetNode;
   };
 
 } // namespace
 
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkProcessExecutor.cpp b/Modules/Segmentation/Interactions/mitkProcessExecutor.cpp
index d65969bb8a..cd0aa04854 100644
--- a/Modules/Segmentation/Interactions/mitkProcessExecutor.cpp
+++ b/Modules/Segmentation/Interactions/mitkProcessExecutor.cpp
@@ -1,153 +1,161 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkProcessExecutor.h"
 
 #include <fstream>
 #include <iostream>
 #include <itksys/Process.h>
 #include <itksys/SystemTools.hxx>
 
 namespace mitk
 {
   std::string ProcessExecutor::GetOSDependendExecutableName(const std::string &name)
   {
 #if defined(_WIN32)
 
     if (itksys::SystemTools::GetFilenameLastExtension(name).empty())
     {
       return name + ".exe";
     }
 
     return name;
 
 #else
     auto result = itksys::SystemTools::GetFilenamePath(name);
     if (EnsureCorrectOSPathSeparator(result).empty())
     {
       return "./" + name;
     }
     else
     {
       return name;
     }
 
 #endif
   }
 
   std::string ProcessExecutor::EnsureCorrectOSPathSeparator(const std::string &path)
   {
     std::string ret = path;
 
 #ifdef _WIN32
     const std::string curSep = "\\";
     const char wrongSep = '/';
 #else
     const std::string curSep = "/";
     const char wrongSep = '\\';
 #endif
 
     std::string::size_type pos = ret.find_first_of(wrongSep);
 
     while (pos != std::string::npos)
     {
       ret.replace(pos, 1, curSep);
 
       pos = ret.find_first_of(wrongSep);
     }
 
     return ret;
   }
 
   int ProcessExecutor::GetExitValue() { return this->m_ExitValue; };
 
   bool ProcessExecutor::Execute(const std::string &executionPath, const ArgumentListType &argumentList)
   {
     std::vector<const char*> pArguments_(argumentList.size() + 1);
 
     for (ArgumentListType::size_type index = 0; index < argumentList.size(); ++index)
     {
       pArguments_[index] = argumentList[index].c_str();
     }
     pArguments_.push_back(nullptr); //terminating null element as required by ITK
 
     bool normalExit = false;
 
     try
     {
-      itksysProcess *processID = itksysProcess_New();
-      itksysProcess_SetCommand(processID, pArguments_.data());
+      m_ProcessID = itksysProcess_New();
+      itksysProcess_SetCommand(m_ProcessID, pArguments_.data());
 
-      itksysProcess_SetWorkingDirectory(processID, executionPath.c_str());
+      itksysProcess_SetWorkingDirectory(m_ProcessID, executionPath.c_str());
 
       if (this->m_SharedOutputPipes)
       {
-        itksysProcess_SetPipeShared(processID, itksysProcess_Pipe_STDOUT, 1);
-        itksysProcess_SetPipeShared(processID, itksysProcess_Pipe_STDERR, 1);
+        itksysProcess_SetPipeShared(m_ProcessID, itksysProcess_Pipe_STDOUT, 1);
+        itksysProcess_SetPipeShared(m_ProcessID, itksysProcess_Pipe_STDERR, 1);
       }
 
-      itksysProcess_Execute(processID);
+      itksysProcess_Execute(m_ProcessID);
 
       char *rawOutput = nullptr;
       int outputLength = 0;
       while (true)
       {
-        int dataStatus = itksysProcess_WaitForData(processID, &rawOutput, &outputLength, nullptr);
+        int dataStatus = itksysProcess_WaitForData(m_ProcessID, &rawOutput, &outputLength, nullptr);
 
         if (dataStatus == itksysProcess_Pipe_STDOUT)
         {
           std::string data(rawOutput, outputLength);
           this->InvokeEvent(ExternalProcessStdOutEvent(data));
         }
         else if (dataStatus == itksysProcess_Pipe_STDERR)
         {
           std::string data(rawOutput, outputLength);
           this->InvokeEvent(ExternalProcessStdErrEvent(data));
         }
         else
         {
           break;
         }
       }
 
-      itksysProcess_WaitForExit(processID, nullptr);
+      itksysProcess_WaitForExit(m_ProcessID, nullptr);
 
-      auto state = static_cast<itksysProcess_State_e>(itksysProcess_GetState(processID));
+      auto state = static_cast<itksysProcess_State_e>(itksysProcess_GetState(m_ProcessID));
 
       normalExit = (state == itksysProcess_State_Exited);
-      this->m_ExitValue = itksysProcess_GetExitValue(processID);
+      this->m_ExitValue = itksysProcess_GetExitValue(m_ProcessID);
     }
     catch (...)
     {
       throw;
     }
     return normalExit;
   };
 
   bool ProcessExecutor::Execute(const std::string &executionPath,
                                 const std::string &executableName,
-                                ArgumentListType argumentList)
+                                ArgumentListType &argumentList)
   {
     std::string executableName_OS = GetOSDependendExecutableName(executableName);
     argumentList.insert(argumentList.begin(), executableName_OS);
 
     return Execute(executionPath, argumentList);
   }
 
+  void ProcessExecutor::KillProcess()
+  {
+    if (m_ProcessID != nullptr)
+    {
+      itksysProcess_Kill(m_ProcessID);
+    }
+  }
+
   ProcessExecutor::ProcessExecutor()
   {
     this->m_ExitValue = 0;
     this->m_SharedOutputPipes = false;
   }
 
   ProcessExecutor::~ProcessExecutor() = default;
 } // namespace mitk
diff --git a/Modules/Segmentation/Interactions/mitkProcessExecutor.h b/Modules/Segmentation/Interactions/mitkProcessExecutor.h
index 79856889b4..ffce84f3d4 100644
--- a/Modules/Segmentation/Interactions/mitkProcessExecutor.h
+++ b/Modules/Segmentation/Interactions/mitkProcessExecutor.h
@@ -1,110 +1,116 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // Class is adapted from MatchPoint ProcessExecutor
 
 #ifndef __MITK_PROCESS_EXECUTOR_H
 #define __MITK_PROCESS_EXECUTOR_H
 
 #include <MitkSegmentationExports.h>
 #include <itkObject.h>
 #include <vector>
+#include <itksys/Process.h>
 
 namespace mitk
 {
   class ExternalProcessOutputEvent : public itk::AnyEvent
   {
   public:
     typedef ExternalProcessOutputEvent Self;
     typedef itk::AnyEvent Superclass;
 
     explicit ExternalProcessOutputEvent(const std::string &output = "") : m_Output(output) {}
     ~ExternalProcessOutputEvent() override {}
 
     const char *GetEventName() const override { return "ExternalProcessOutputEvent"; }
     bool CheckEvent(const ::itk::EventObject *e) const override { return dynamic_cast<const Self *>(e); }
     itk::EventObject *MakeObject() const override { return new Self(m_Output); }
     std::string GetOutput() const { return m_Output; }
 
   private:
     std::string m_Output;
   };
 
 #define mitkProcessExecutorEventMacro(classname)                                                                       \
   class classname : public ExternalProcessOutputEvent                                                                  \
   {                                                                                                                    \
   public:                                                                                                              \
     typedef classname Self;                                                                                            \
     typedef ExternalProcessOutputEvent Superclass;                                                                     \
                                                                                                                        \
     explicit classname(const std::string &output) : Superclass(output) {}                                              \
     ~classname() override {}                                                                                           \
                                                                                                                        \
     virtual const char *GetEventName() const { return #classname; }                                                    \
     virtual bool CheckEvent(const ::itk::EventObject *e) const { return dynamic_cast<const Self *>(e); }               \
     virtual ::itk::EventObject *MakeObject() const { return new Self(this->GetOutput()); }                             \
   };
 
   mitkProcessExecutorEventMacro(ExternalProcessStdOutEvent);
   mitkProcessExecutorEventMacro(ExternalProcessStdErrEvent);
 
   /**
    * @brief You may register an observer for an ExternalProcessOutputEvent, ExternalProcessStdOutEvent or
    * ExternalProcessStdErrEvent in order to get notified of any output.
    * @remark The events will only be invoked if the pipes are NOT(!) shared. By default the pipes are not shared.
    *
    */
   class MITKSEGMENTATION_EXPORT ProcessExecutor : public itk::Object
   {
   public:
     using Self = ProcessExecutor;
     using Superclass = ::itk::Object;
     using Pointer = ::itk::SmartPointer<Self>;
     using ConstPointer = ::itk::SmartPointer<const Self>;
 
     itkTypeMacro(ProcessExecutor, ::itk::Object);
     itkFactorylessNewMacro(Self);
 
     itkSetMacro(SharedOutputPipes, bool);
     itkGetConstMacro(SharedOutputPipes, bool);
 
     using ArgumentListType = std::vector<std::string>;
 
-    bool Execute(const std::string &executionPath, const std::string &executableName, ArgumentListType argumentList);
+    bool Execute(const std::string &executionPath, const std::string &executableName, ArgumentListType &argumentList);
 
     /**
      * @brief Executes the process. This version assumes that the executable name is the first argument in the argument
      * list and has already been converted to its OS dependent name via the static convert function of this class.
      */
     bool Execute(const std::string &executionPath, const ArgumentListType &argumentList);
 
     int GetExitValue();
     static std::string EnsureCorrectOSPathSeparator(const std::string &);
 
     static std::string GetOSDependendExecutableName(const std::string &name);
 
+    void KillProcess();
+
   protected:
     ProcessExecutor();
     ~ProcessExecutor() override;
 
     int m_ExitValue;
 
     /**
      * @brief Specifies if the child process should share the output pipes (true) or not (false).
      * If pipes are not shared the output will be passed by invoking ExternalProcessOutputEvents
      * @remark The events will only be invoked if the pipes are NOT(!) shared.
      */
     bool m_SharedOutputPipes;
+
+  private:
+    itksysProcess *m_ProcessID = nullptr;
   };
 
 } // namespace mitk
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index 5ccc2dc29b..ca9a769dfd 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,757 +1,757 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkSegTool2D.h"
 #include "mitkToolManager.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkDataStorage.h"
 
 #include "mitkPlaneGeometry.h"
 
 // Include of the new ImageExtractor
 #include "mitkMorphologicalOperations.h"
 #include "mitkPlanarCircle.h"
 
 #include "usGetModuleContext.h"
 
 // Includes for 3DSurfaceInterpolation
 #include "mitkImageTimeSelector.h"
 #include "mitkImageToContourFilter.h"
 #include "mitkSurfaceInterpolationController.h"
 
 // includes for resling and overwriting
 #include <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include <mitkDiffSliceOperationApplier.h>
 
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkLabelSetImage.h"
 
 #include "mitkContourModelUtils.h"
 
 #include "itkImageRegionIterator.h"
 
 #define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
 
 bool mitk::SegTool2D::m_SurfaceInterpolationEnabled = true;
 
 mitk::SegTool2D::SliceInformation::SliceInformation(const mitk::Image* aSlice, const mitk::PlaneGeometry* aPlane, mitk::TimeStepType aTimestep) :
   slice(aSlice), plane(aPlane), timestep(aTimestep)
 {
 }
 
 mitk::SegTool2D::SegTool2D(const char *type, const us::Module *interactorModule)
   : Tool(type, interactorModule), m_Contourmarkername("Position")
 {
   Tool::m_EventConfig = "DisplayConfigBlockLMB.xml";
 }
 
 mitk::SegTool2D::~SegTool2D()
 {
 }
 
 bool mitk::SegTool2D::FilterEvents(InteractionEvent *interactionEvent, DataNode *)
 {
   const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
 
   bool isValidEvent =
     (positionEvent && // Only events of type mitk::InteractionPositionEvent
      interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D // Only events from the 2D renderwindows
      );
   return isValidEvent;
 }
 
 bool mitk::SegTool2D::DetermineAffectedImageSlice(const Image *image,
                                                   const PlaneGeometry *plane,
                                                   int &affectedDimension,
                                                   int &affectedSlice)
 {
   assert(image);
   assert(plane);
 
   // compare normal of plane to the three axis vectors of the image
   Vector3D normal = plane->GetNormal();
   Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
   Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
   Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
 
   normal.Normalize();
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   imageNormal0.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal0.GetVnlVector()));
   imageNormal1.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal1.GetVnlVector()));
   imageNormal2.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal2.GetVnlVector()));
 
   double eps(0.00001);
   // axial
   if (imageNormal2.GetNorm() <= eps)
   {
     affectedDimension = 2;
   }
   // sagittal
   else if (imageNormal1.GetNorm() <= eps)
   {
     affectedDimension = 1;
   }
-  // frontal
+  // coronal
   else if (imageNormal0.GetNorm() <= eps)
   {
     affectedDimension = 0;
   }
   else
   {
     affectedDimension = -1; // no idea
     return false;
   }
 
   // determine slice number in image
   BaseGeometry *imageGeometry = image->GetGeometry(0);
   Point3D testPoint = imageGeometry->GetCenter();
   Point3D projectedPoint;
   plane->Project(testPoint, projectedPoint);
 
   Point3D indexPoint;
 
   imageGeometry->WorldToIndex(projectedPoint, indexPoint);
   affectedSlice = ROUND(indexPoint[affectedDimension]);
   MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice "
              << affectedSlice;
 
   // check if this index is still within the image
   if (affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)))
     return false;
 
   return true;
 }
 
 void mitk::SegTool2D::UpdateSurfaceInterpolation(const Image *slice,
                                                  const Image *workingImage,
                                                  const PlaneGeometry *plane,
                                                  bool detectIntersection)
 {
   std::vector<SliceInformation> slices = { SliceInformation(slice, plane, 0)};
   Self::UpdateSurfaceInterpolation(slices, workingImage, detectIntersection);
 }
 
 void  mitk::SegTool2D::RemoveContourFromInterpolator(const SliceInformation& sliceInfo)
 {
   mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
   contourInfo.contourNormal = sliceInfo.plane->GetNormal();
   contourInfo.contourPoint = sliceInfo.plane->GetOrigin();
   mitk::SurfaceInterpolationController::GetInstance()->RemoveContour(contourInfo);
 }
 
 void mitk::SegTool2D::UpdateSurfaceInterpolation(const std::vector<SliceInformation>& sliceInfos,
   const Image* workingImage,
   bool detectIntersection)
 {
   if (!m_SurfaceInterpolationEnabled)
     return;
 
   //Remark: the ImageTimeSelector is just needed to extract a timestep/channel of
   //the image in order to get the image dimension (time dimension and channel dimension
   //stripped away). Therfore it is OK to always use time step 0 and channel 0
   mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
   timeSelector->SetInput(workingImage);
   timeSelector->SetTimeNr(0);
   timeSelector->SetChannelNr(0);
   timeSelector->Update();
   const auto dimRefImg = timeSelector->GetOutput()->GetDimension();
 
   if (dimRefImg != 3)
     return;
 
   std::vector<mitk::Surface::Pointer> contourList;
   contourList.reserve(sliceInfos.size());
 
   ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
 
   std::vector<SliceInformation> relevantSlices = sliceInfos;
 
   if (detectIntersection)
   {
     relevantSlices.clear();
 
     for (const auto& sliceInfo : sliceInfos)
     {
       // Test whether there is something to extract or whether the slice just contains intersections of others
       mitk::Image::Pointer slice2 = sliceInfo.slice->Clone();
       mitk::MorphologicalOperations::Erode(slice2, 2, mitk::MorphologicalOperations::Ball);
 
       contourExtractor->SetInput(slice2);
       contourExtractor->Update();
       mitk::Surface::Pointer contour = contourExtractor->GetOutput();
 
       if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
       {
         Self::RemoveContourFromInterpolator(sliceInfo);
       }
       else
       {
         relevantSlices.push_back(sliceInfo);
       }
     }
   }
 
   if (relevantSlices.empty())
     return;
 
   for (const auto& sliceInfo : relevantSlices)
   {
 
     contourExtractor->SetInput(sliceInfo.slice);
     contourExtractor->Update();
     mitk::Surface::Pointer contour = contourExtractor->GetOutput();
 
     if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
     {
       Self::RemoveContourFromInterpolator(sliceInfo);
     }
     else
     {
       contour->DisconnectPipeline();
       contourList.push_back(contour);
     }
   }
   mitk::SurfaceInterpolationController::GetInstance()->AddNewContours(contourList);
 }
 
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const InteractionPositionEvent *positionEvent, const Image *image, unsigned int component /*= 0*/)
 {
   if (!positionEvent)
   {
     return nullptr;
   }
 
   assert(positionEvent->GetSender()); // sure, right?
   const auto timeStep = positionEvent->GetSender()->GetTimeStep(image); // get the timestep of the visible part (time-wise) of the image
 
   return GetAffectedImageSliceAs2DImage(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry(), image, timeStep, component);
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(const PlaneGeometry* planeGeometry, const Image* image, TimePointType timePoint, unsigned int component /*= 0*/)
 {
   if (!image || !planeGeometry)
   {
     return nullptr;
   }
 
   if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
     return nullptr;
 
   return SegTool2D::GetAffectedImageSliceAs2DImage(planeGeometry, image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint), component);
 }
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PlaneGeometry *planeGeometry, const Image *image, TimeStepType timeStep, unsigned int component /*= 0*/)
 {
   if (!image || !planeGeometry)
   {
     return nullptr;
   }
 
   // Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   // set to false to extract a slice
   reslice->SetOverwriteMode(false);
   reslice->Modified();
 
   // use ExtractSliceFilter with our specific vtkImageReslice for overwriting and extracting
   mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput(image);
   extractor->SetTimeStep(timeStep);
   extractor->SetWorldGeometry(planeGeometry);
   extractor->SetVtkOutputRequest(false);
   extractor->SetResliceTransformByGeometry(image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
   // additionally extract the given component
   // default is 0; the extractor checks for multi-component images
   extractor->SetComponent(component);
 
   extractor->Modified();
   extractor->Update();
 
   Image::Pointer slice = extractor->GetOutput();
 
   return slice;
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const InteractionPositionEvent *positionEvent) const
 {
   const auto workingNode = this->GetWorkingDataNode();
   if (!workingNode)
   {
     return nullptr;
   }
 
   const auto *workingImage = dynamic_cast<Image *>(workingNode->GetData());
   if (!workingImage)
   {
     return nullptr;
   }
 
   return GetAffectedImageSliceAs2DImage(positionEvent, workingImage);
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const InteractionPositionEvent *positionEvent) const
 {
   DataNode* referenceNode = this->GetReferenceDataNode();
   if (!referenceNode)
   {
     return nullptr;
   }
 
   auto *referenceImage = dynamic_cast<Image *>(referenceNode->GetData());
   if (!referenceImage)
   {
     return nullptr;
   }
 
   int displayedComponent = 0;
   if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
   {
     // found the displayed component
     return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage, displayedComponent);
   }
   else
   {
     return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage);
   }
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const PlaneGeometry* planeGeometry, TimeStepType timeStep) const
 {
   DataNode* referenceNode = this->GetReferenceDataNode();
   if (!referenceNode)
   {
     return nullptr;
   }
 
   auto* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
   if (!referenceImage)
   {
     return nullptr;
   }
 
   int displayedComponent = 0;
   if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
   {
     // found the displayed component
     return GetAffectedImageSliceAs2DImage(planeGeometry, referenceImage, timeStep, displayedComponent);
   }
   else
   {
     return GetAffectedImageSliceAs2DImage(planeGeometry, referenceImage, timeStep);
   }
 }
 
 void mitk::SegTool2D::Activated()
 {
   Superclass::Activated();
 
   this->GetToolManager()->SelectedTimePointChanged +=
     mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
 
   m_LastTimePointTriggered = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 }
 
 void mitk::SegTool2D::Deactivated()
 {
   this->GetToolManager()->SelectedTimePointChanged -=
     mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
   Superclass::Deactivated();
 }
 
 void mitk::SegTool2D::OnTimePointChangedInternal()
 {
   if (m_IsTimePointChangeAware && nullptr != this->GetWorkingDataNode())
   {
     const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
     if (timePoint != m_LastTimePointTriggered)
     {
       m_LastTimePointTriggered = timePoint;
       this->OnTimePointChanged();
     }
   }
 }
 
 void mitk::SegTool2D::OnTimePointChanged()
 {
   //default implementation does nothing
 }
 
 mitk::DataNode* mitk::SegTool2D::GetWorkingDataNode() const
 {
   if (nullptr != this->GetToolManager())
   {
     return this->GetToolManager()->GetWorkingData(0);
   }
   return nullptr;
 }
 
 mitk::Image* mitk::SegTool2D::GetWorkingData() const
 {
   auto node = this->GetWorkingDataNode();
   if (nullptr != node)
   {
     return dynamic_cast<Image*>(node->GetData());
   }
   return nullptr;
 }
 
 mitk::DataNode* mitk::SegTool2D::GetReferenceDataNode() const
 {
   if (nullptr != this->GetToolManager())
   {
     return this->GetToolManager()->GetReferenceData(0);
   }
   return nullptr;
 }
 
 mitk::Image* mitk::SegTool2D::GetReferenceData() const
 {
   auto node = this->GetReferenceDataNode();
   if (nullptr != node)
   {
     return dynamic_cast<Image*>(node->GetData());
   }
   return nullptr;
 }
 
 
 void mitk::SegTool2D::WriteBackSegmentationResult(const InteractionPositionEvent *positionEvent, const Image * segmentationResult)
 {
   if (!positionEvent)
     return;
 
   const PlaneGeometry *planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
   const auto *abstractTransformGeometry(
     dynamic_cast<const AbstractTransformGeometry *>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
 
   if (planeGeometry && segmentationResult && !abstractTransformGeometry)
   {
     const auto workingNode = this->GetWorkingDataNode();
     auto *image = dynamic_cast<Image *>(workingNode->GetData());
     const auto timeStep = positionEvent->GetSender()->GetTimeStep(image);
     this->WriteBackSegmentationResult(planeGeometry, segmentationResult, timeStep);
   }
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResult(const DataNode* workingNode, const PlaneGeometry* planeGeometry, const Image* segmentationResult, TimeStepType timeStep)
 {
   if (!planeGeometry || !segmentationResult)
     return;
 
   SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry*>(planeGeometry), timeStep);
   Self::WriteBackSegmentationResults(workingNode, { sliceInfo }, true);
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResult(const PlaneGeometry *planeGeometry,
                                                   const Image * segmentationResult,
                                                   TimeStepType timeStep)
 {
   if (!planeGeometry || !segmentationResult)
     return;
 
   SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry *>(planeGeometry), timeStep);
   WriteBackSegmentationResults({ sliceInfo }, true);
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResults(const std::vector<SegTool2D::SliceInformation> &sliceList,
                                                   bool writeSliceToVolume)
 {
   if (sliceList.empty())
   {
     return;
   }
 
   if (nullptr == m_LastEventSender)
   {
     MITK_WARN << "Cannot write tool results. Tool seems to be in an invalid state, as no interaction event was recieved but is expected.";
     return;
   }
 
   const auto workingNode = this->GetWorkingDataNode();
 
   mitk::SegTool2D::WriteBackSegmentationResults(workingNode, sliceList, writeSliceToVolume);
 
   // the first geometry is needed otherwise restoring the position is not working
   const auto* plane3 =
     dynamic_cast<const PlaneGeometry*>(dynamic_cast<const mitk::SlicedGeometry3D*>(
       m_LastEventSender->GetSliceNavigationController()->GetCurrentGeometry3D())
       ->GetPlaneGeometry(0));
   unsigned int slicePosition = m_LastEventSender->GetSliceNavigationController()->GetSlice()->GetPos();
 
   /* A cleaner solution would be to add a contour marker for each slice info. It currently
    does not work as the contour markers expect that the plane is always the plane of slice 0.
    Had not the time to do it properly no. Should be solved by T28146*/
   this->AddContourmarker(plane3, slicePosition);
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResults(const DataNode* workingNode, const std::vector<SliceInformation>& sliceList, bool writeSliceToVolume)
 {
   if (sliceList.empty())
   {
     return;
   }
 
   if (nullptr == workingNode)
   {
     mitkThrow() << "Cannot write slice to working node. Working node is invalid.";
   }
 
   auto* image = dynamic_cast<Image*>(workingNode->GetData());
 
   if (nullptr == image)
   {
     mitkThrow() << "Cannot write slice to working node. Working node does not contain an image.";
   }
 
   for (const auto& sliceInfo : sliceList)
   {
     if (writeSliceToVolume && nullptr != sliceInfo.plane && sliceInfo.slice.IsNotNull())
     {
       mitk::SegTool2D::WriteSliceToVolume(image, sliceInfo, true);
     }
   }
 
   mitk::SegTool2D::UpdateSurfaceInterpolation(sliceList, image, false);
 
   // also mark its node as modified (T27308). Can be removed if T27307
   // is properly solved
   if (workingNode != nullptr) workingNode->Modified();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::SegTool2D::WriteSliceToVolume(Image* workingImage, const PlaneGeometry* planeGeometry, const Image* slice, TimeStepType timeStep, bool allowUndo)
 {
   SliceInformation sliceInfo(slice, planeGeometry, timeStep);
   WriteSliceToVolume(workingImage, sliceInfo , allowUndo);
 }
 
 void mitk::SegTool2D::WriteSliceToVolume(Image* workingImage, const SliceInformation &sliceInfo, bool allowUndo)
 {
   if (nullptr == workingImage)
   {
     mitkThrow() << "Cannot write slice to working node. Working node does not contain an image.";
   }
 
   DiffSliceOperation* undoOperation = nullptr;
 
   if (allowUndo)
   {
     /*============= BEGIN undo/redo feature block ========================*/
     // Create undo operation by caching the not yet modified slices
     mitk::Image::Pointer originalSlice = GetAffectedImageSliceAs2DImage(sliceInfo.plane, workingImage, sliceInfo.timestep);
     undoOperation =
       new DiffSliceOperation(workingImage,
         originalSlice,
         dynamic_cast<SlicedGeometry3D*>(originalSlice->GetGeometry()),
         sliceInfo.timestep,
         sliceInfo.plane);
     /*============= END undo/redo feature block ========================*/
   }
 
   // Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
   // reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
   // Set the slice as 'input'
   // casting const away is needed and OK as long the OverwriteMode of
   // mitkVTKImageOverwrite is true.
   // Reason: because then the input slice is not touched but
   // used to overwrite the input of the ExtractSliceFilter.
   auto noneConstSlice = const_cast<Image*>(sliceInfo.slice.GetPointer());
   reslice->SetInputSlice(noneConstSlice->GetVtkImageData());
 
   // set overwrite mode to true to write back to the image volume
   reslice->SetOverwriteMode(true);
   reslice->Modified();
 
   mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput(workingImage);
   extractor->SetTimeStep(sliceInfo.timestep);
   extractor->SetWorldGeometry(sliceInfo.plane);
   extractor->SetVtkOutputRequest(false);
   extractor->SetResliceTransformByGeometry(workingImage->GetGeometry(sliceInfo.timestep));
 
   extractor->Modified();
   extractor->Update();
 
   // the image was modified within the pipeline, but not marked so
   workingImage->Modified();
   workingImage->GetVtkImageData()->Modified();
 
   if (allowUndo)
   {
     /*============= BEGIN undo/redo feature block ========================*/
     // specify the redo operation with the edited slice
     auto* doOperation =
       new DiffSliceOperation(workingImage,
         extractor->GetOutput(),
         dynamic_cast<SlicedGeometry3D*>(sliceInfo.slice->GetGeometry()),
         sliceInfo.timestep,
         sliceInfo.plane);
 
     // create an operation event for the undo stack
     OperationEvent* undoStackItem =
       new OperationEvent(DiffSliceOperationApplier::GetInstance(), doOperation, undoOperation, "Segmentation");
 
     // add it to the undo controller
     UndoStackItem::IncCurrObjectEventId();
     UndoStackItem::IncCurrGroupEventId();
     UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
     /*============= END undo/redo feature block ========================*/
   }
 
 }
 
 
 void mitk::SegTool2D::SetShowMarkerNodes(bool status)
 {
   m_ShowMarkerNodes = status;
 }
 
 void mitk::SegTool2D::SetEnable3DInterpolation(bool enabled)
 {
   m_SurfaceInterpolationEnabled = enabled;
 }
 
 
 int mitk::SegTool2D::AddContourmarker(const PlaneGeometry* planeGeometry, unsigned int sliceIndex)
 {
   if (planeGeometry == nullptr)
     return -1;
 
   us::ServiceReference<PlanePositionManagerService> serviceRef =
     us::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
   PlanePositionManagerService *service = us::GetModuleContext()->GetService(serviceRef);
 
   unsigned int size = service->GetNumberOfPlanePositions();
   unsigned int id = service->AddNewPlanePosition(planeGeometry, sliceIndex);
 
   mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
   mitk::Point2D p1;
   planeGeometry->Map(planeGeometry->GetCenter(), p1);
   mitk::Point2D p2 = p1;
   p2[0] -= planeGeometry->GetSpacing()[0];
   p2[1] -= planeGeometry->GetSpacing()[1];
   contourMarker->PlaceFigure(p1);
   contourMarker->SetCurrentControlPoint(p1);
   contourMarker->SetPlaneGeometry(planeGeometry->Clone());
 
   std::stringstream markerStream;
   auto workingNode = this->GetWorkingDataNode();
 
   markerStream << m_Contourmarkername;
   markerStream << " ";
   markerStream << id + 1;
 
   DataNode::Pointer rotatedContourNode = DataNode::New();
 
   rotatedContourNode->SetData(contourMarker);
   rotatedContourNode->SetProperty("name", StringProperty::New(markerStream.str()));
   rotatedContourNode->SetProperty("isContourMarker", BoolProperty::New(true));
   rotatedContourNode->SetBoolProperty("PlanarFigureInitializedWindow", true, m_LastEventSender);
   rotatedContourNode->SetProperty("includeInBoundingBox", BoolProperty::New(false));
   rotatedContourNode->SetProperty("helper object", mitk::BoolProperty::New(!m_ShowMarkerNodes));
   rotatedContourNode->SetProperty("planarfigure.drawcontrolpoints", BoolProperty::New(false));
   rotatedContourNode->SetProperty("planarfigure.drawname", BoolProperty::New(false));
   rotatedContourNode->SetProperty("planarfigure.drawoutline", BoolProperty::New(false));
   rotatedContourNode->SetProperty("planarfigure.drawshadow", BoolProperty::New(false));
 
   if (planeGeometry)
   {
     if (id == size)
     {
       this->GetToolManager()->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
     else
     {
       mitk::NodePredicateProperty::Pointer isMarker =
         mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
 
       mitk::DataStorage::SetOfObjects::ConstPointer markers =
         this->GetToolManager()->GetDataStorage()->GetDerivations(workingNode, isMarker);
 
       for (auto iter = markers->begin(); iter != markers->end(); ++iter)
       {
         std::string nodeName = (*iter)->GetName();
         unsigned int t = nodeName.find_last_of(" ");
         unsigned int markerId = atof(nodeName.substr(t + 1).c_str()) - 1;
         if (id == markerId)
         {
           return id;
         }
       }
       this->GetToolManager()->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
   }
   return id;
 }
 
 void mitk::SegTool2D::InteractiveSegmentationBugMessage(const std::string &message) const
 {
   MITK_ERROR << "********************************************************************************" << std::endl
              << " " << message << std::endl
              << "********************************************************************************" << std::endl
              << "  " << std::endl
              << " If your image is rotated or the 2D views don't really contain the patient image, try to press the "
                 "button next to the image selection. "
              << std::endl
              << "  " << std::endl
              << " Please file a BUG REPORT: " << std::endl
              << " https://phabricator.mitk.org/" << std::endl
              << " Contain the following information:" << std::endl
              << "  - What image were you working on?" << std::endl
              << "  - Which region of the image?" << std::endl
              << "  - Which tool did you use?" << std::endl
              << "  - What did you do?" << std::endl
              << "  - What happened (not)? What did you expect?" << std::endl;
 }
 
 void mitk::SegTool2D::WritePreviewOnWorkingImage(
   Image *targetSlice, const Image *sourceSlice, const Image *workingImage, int paintingPixelValue)
 {
   if (nullptr == targetSlice)
   {
     mitkThrow() << "Cannot write preview on working image. Target slice does not point to a valid instance.";
   }
 
   if (nullptr == sourceSlice)
   {
     mitkThrow() << "Cannot write preview on working image. Source slice does not point to a valid instance.";
   }
 
   if (nullptr == workingImage)
   {
     mitkThrow() << "Cannot write preview on working image. Working image does not point to a valid instance.";
   }
 
   auto constVtkSource = sourceSlice->GetVtkImageData();
   /*Need to const cast because Vtk interface does not support const correctly.
    (or I am not experienced enough to use it correctly)*/
   auto nonConstVtkSource = const_cast<vtkImageData*>(constVtkSource);
 
   ContourModelUtils::FillSliceInSlice(nonConstVtkSource, targetSlice->GetVtkImageData(), workingImage, paintingPixelValue, 1.0);
 }
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp b/Modules/Segmentation/Interactions/mitkSegWithPreviewTool.cpp
similarity index 62%
rename from Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
rename to Modules/Segmentation/Interactions/mitkSegWithPreviewTool.cpp
index 2ddbe65aec..0a5b9717bf 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegWithPreviewTool.cpp
@@ -1,736 +1,732 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
-#include "mitkAutoSegmentationWithPreviewTool.h"
+#include "mitkSegWithPreviewTool.h"
 
 #include "mitkToolManager.h"
 
 #include "mitkColorProperty.h"
-#include "mitkLevelWindowProperty.h"
 #include "mitkProperties.h"
 
 #include "mitkDataStorage.h"
 #include "mitkRenderingManager.h"
-#include <mitkSliceNavigationController.h>
 
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
-#include "mitkImageStatisticsHolder.h"
-#include "mitkImageTimeSelector.h"
 #include "mitkLabelSetImage.h"
 #include "mitkMaskAndCutRoiImageFilter.h"
 #include "mitkPadImageFilter.h"
 #include "mitkNodePredicateGeometry.h"
 #include "mitkSegTool2D.h"
 
-#include <itkBinaryFunctorImageFilter.h>
-
-mitk::AutoSegmentationWithPreviewTool::AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews): m_LazyDynamicPreviews(lazyDynamicPreviews)
+mitk::SegWithPreviewTool::SegWithPreviewTool(bool lazyDynamicPreviews): Tool("dummy"), m_LazyDynamicPreviews(lazyDynamicPreviews)
 {
   m_ProgressCommand = ToolCommand::New();
 }
 
-mitk::AutoSegmentationWithPreviewTool::AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule) : AutoSegmentationTool(interactorType, interactorModule), m_LazyDynamicPreviews(lazyDynamicPreviews)
+mitk::SegWithPreviewTool::SegWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule) : Tool(interactorType, interactorModule), m_LazyDynamicPreviews(lazyDynamicPreviews)
 {
   m_ProgressCommand = ToolCommand::New();
 }
 
-mitk::AutoSegmentationWithPreviewTool::~AutoSegmentationWithPreviewTool()
+mitk::SegWithPreviewTool::~SegWithPreviewTool()
+{
+}
+
+void mitk::SegWithPreviewTool::SetMergeStyle(MultiLabelSegmentation::MergeStyle mergeStyle)
+{
+  m_MergeStyle = mergeStyle;
+}
+
+void mitk::SegWithPreviewTool::SetOverwriteStyle(MultiLabelSegmentation::OverwriteStyle overwriteStyle)
+{
+  m_OverwriteStyle = overwriteStyle;
+}
+
+void mitk::SegWithPreviewTool::SetLabelTransferMode(LabelTransferMode LabelTransferMode)
+{
+  m_LabelTransferMode = LabelTransferMode;
+}
+
+void mitk::SegWithPreviewTool::SetSelectedLabels(const SelectedLabelVectorType& labelsToTransfer)
 {
+  m_SelectedLabels = labelsToTransfer;
 }
 
-bool mitk::AutoSegmentationWithPreviewTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
+bool mitk::SegWithPreviewTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
 {
   if (!Superclass::CanHandle(referenceData, workingData))
     return false;
 
   if (workingData == nullptr)
     return true;
 
   auto* labelSet = dynamic_cast<const LabelSetImage*>(workingData);
 
   if (labelSet != nullptr)
     return true;
 
   auto* image = dynamic_cast<const Image*>(workingData);
 
   if (image == nullptr)
     return false;
 
   //if it is a normal image and not a label set image is used as working data
   //it must have the same pixel type as a label set.
   return MakeScalarPixelType< DefaultSegmentationDataType >() == image->GetPixelType();
 }
 
-void mitk::AutoSegmentationWithPreviewTool::Activated()
+void mitk::SegWithPreviewTool::Activated()
 {
   Superclass::Activated();
 
   this->GetToolManager()->RoiDataChanged +=
-    MessageDelegate<AutoSegmentationWithPreviewTool>(this, &AutoSegmentationWithPreviewTool::OnRoiDataChanged);
+    MessageDelegate<SegWithPreviewTool>(this, &SegWithPreviewTool::OnRoiDataChanged);
 
   this->GetToolManager()->SelectedTimePointChanged +=
-    MessageDelegate<AutoSegmentationWithPreviewTool>(this, &AutoSegmentationWithPreviewTool::OnTimePointChanged);
+    MessageDelegate<SegWithPreviewTool>(this, &SegWithPreviewTool::OnTimePointChanged);
 
   m_ReferenceDataNode = this->GetToolManager()->GetReferenceData(0);
   m_SegmentationInputNode = m_ReferenceDataNode;
 
   m_LastTimePointOfUpdate = RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
   if (m_PreviewSegmentationNode.IsNull())
   {
     m_PreviewSegmentationNode = DataNode::New();
     m_PreviewSegmentationNode->SetProperty("color", ColorProperty::New(0.0, 1.0, 0.0));
     m_PreviewSegmentationNode->SetProperty("name", StringProperty::New(std::string(this->GetName())+" preview"));
     m_PreviewSegmentationNode->SetProperty("opacity", FloatProperty::New(0.3));
     m_PreviewSegmentationNode->SetProperty("binary", BoolProperty::New(true));
     m_PreviewSegmentationNode->SetProperty("helper object", BoolProperty::New(true));
   }
 
   if (m_SegmentationInputNode.IsNotNull())
   {
     this->ResetPreviewNode();
     this->InitiateToolByInput();
   }
   else
   {
     this->GetToolManager()->ActivateTool(-1);
   }
 }
 
-void mitk::AutoSegmentationWithPreviewTool::Deactivated()
+void mitk::SegWithPreviewTool::Deactivated()
 {
   this->GetToolManager()->RoiDataChanged -=
-    MessageDelegate<AutoSegmentationWithPreviewTool>(this, &AutoSegmentationWithPreviewTool::OnRoiDataChanged);
+    MessageDelegate<SegWithPreviewTool>(this, &SegWithPreviewTool::OnRoiDataChanged);
 
   this->GetToolManager()->SelectedTimePointChanged -=
-    MessageDelegate<AutoSegmentationWithPreviewTool>(this, &AutoSegmentationWithPreviewTool::OnTimePointChanged);
+    MessageDelegate<SegWithPreviewTool>(this, &SegWithPreviewTool::OnTimePointChanged);
 
   m_SegmentationInputNode = nullptr;
   m_ReferenceDataNode = nullptr;
   m_WorkingPlaneGeometry = nullptr;
 
   try
   {
     if (DataStorage *storage = this->GetToolManager()->GetDataStorage())
     {
       storage->Remove(m_PreviewSegmentationNode);
       RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
   catch (...)
   {
     // don't care
   }
 
   if (m_PreviewSegmentationNode.IsNotNull())
   {
     m_PreviewSegmentationNode->SetData(nullptr);
   }
 
   Superclass::Deactivated();
 }
 
-void mitk::AutoSegmentationWithPreviewTool::ConfirmSegmentation()
+void mitk::SegWithPreviewTool::ConfirmSegmentation()
 {
   bool labelChanged = this->EnsureUpToDateUserDefinedActiveLabel();
   if ((m_LazyDynamicPreviews && m_CreateAllTimeSteps) || labelChanged)
   { // The tool should create all time steps but is currently in lazy mode,
     // thus ensure that a preview for all time steps is available.
     this->UpdatePreview(true);
   }
 
-
   CreateResultSegmentationFromPreview();
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 
   if (!m_KeepActiveAfterAccept)
   {
     this->GetToolManager()->ActivateTool(-1);
   }
 }
 
-void  mitk::AutoSegmentationWithPreviewTool::InitiateToolByInput()
+void  mitk::SegWithPreviewTool::InitiateToolByInput()
 {
   //default implementation does nothing.
   //implement in derived classes to change behavior
 }
 
-mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetPreviewSegmentation()
+mitk::LabelSetImage* mitk::SegWithPreviewTool::GetPreviewSegmentation()
+{
+  if (m_PreviewSegmentationNode.IsNull())
+  {
+    return nullptr;
+  }
+
+  return dynamic_cast<LabelSetImage*>(m_PreviewSegmentationNode->GetData());
+}
+
+const mitk::LabelSetImage* mitk::SegWithPreviewTool::GetPreviewSegmentation() const
 {
   if (m_PreviewSegmentationNode.IsNull())
   {
     return nullptr;
   }
 
-  return dynamic_cast<Image*>(m_PreviewSegmentationNode->GetData());
+  return dynamic_cast<LabelSetImage*>(m_PreviewSegmentationNode->GetData());
 }
 
-mitk::DataNode* mitk::AutoSegmentationWithPreviewTool::GetPreviewSegmentationNode()
+mitk::DataNode* mitk::SegWithPreviewTool::GetPreviewSegmentationNode()
 {
   return m_PreviewSegmentationNode;
 }
 
-const mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetSegmentationInput() const
+const mitk::Image* mitk::SegWithPreviewTool::GetSegmentationInput() const
 {
   if (m_SegmentationInputNode.IsNull())
   {
     return nullptr;
   }
 
   return dynamic_cast<const Image*>(m_SegmentationInputNode->GetData());
 }
 
-const mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetReferenceData() const
+const mitk::Image* mitk::SegWithPreviewTool::GetReferenceData() const
 {
   if (m_ReferenceDataNode.IsNull())
   {
     return nullptr;
   }
 
   return dynamic_cast<const Image*>(m_ReferenceDataNode->GetData());
 }
 
 template <typename ImageType>
 void ClearBufferProcessing(ImageType* itkImage)
 {
   itkImage->FillBuffer(0);
 }
 
-void mitk::AutoSegmentationWithPreviewTool::ResetPreviewContentAtTimeStep(unsigned int timeStep)
+void mitk::SegWithPreviewTool::ResetPreviewContentAtTimeStep(unsigned int timeStep)
 {
   auto previewImage = GetImageByTimeStep(this->GetPreviewSegmentation(), timeStep);
   if (nullptr != previewImage)
   {
     AccessByItk(previewImage, ClearBufferProcessing);
   }
 }
 
-void mitk::AutoSegmentationWithPreviewTool::ResetPreviewContent()
+void mitk::SegWithPreviewTool::ResetPreviewContent()
 {
   auto previewImage = this->GetPreviewSegmentation();
   if (nullptr != previewImage)
   {
     auto castedPreviewImage =
       dynamic_cast<LabelSetImage*>(previewImage);
     if (nullptr == castedPreviewImage) mitkThrow() << "Application is on wrong state / invalid tool implementation. Preview image should always be of type LabelSetImage now.";
     castedPreviewImage->ClearBuffer();
   }
 }
 
-void mitk::AutoSegmentationWithPreviewTool::ResetPreviewNode()
+void mitk::SegWithPreviewTool::ResetPreviewNode()
 {
   if (m_IsUpdating)
   {
     mitkThrow() << "Used tool is implemented incorrectly. ResetPreviewNode is called while preview update is ongoing. Check implementation!";
   }
 
   itk::RGBPixel<float> previewColor;
   previewColor[0] = 0.0f;
   previewColor[1] = 1.0f;
   previewColor[2] = 0.0f;
 
   const auto image = this->GetSegmentationInput();
   if (nullptr != image)
   {
     LabelSetImage::ConstPointer workingImage =
       dynamic_cast<const LabelSetImage *>(this->GetToolManager()->GetWorkingData(0)->GetData());
 
     if (workingImage.IsNotNull())
     {
       auto newPreviewImage = workingImage->Clone();
       if (this->GetResetsToEmptyPreview())
       {
         newPreviewImage->ClearBuffer();
       }
 
       if (newPreviewImage.IsNull())
       {
         MITK_ERROR << "Cannot create preview helper objects. Unable to clone working image";
         return;
       }
 
       m_PreviewSegmentationNode->SetData(newPreviewImage);
 
       // Let's paint the feedback node green...
       auto* activeLayer = newPreviewImage->GetActiveLabelSet();
       auto* activeLabel = activeLayer->GetActiveLabel();
       activeLabel->SetColor(previewColor);
       activeLayer->UpdateLookupTable(activeLabel->GetValue());
+      activeLabel->SetVisible(true);
     }
     else
     {
       Image::ConstPointer workingImageBin = dynamic_cast<const Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
       if (workingImageBin.IsNotNull())
       {
         Image::Pointer newPreviewImage;
         if (this->GetResetsToEmptyPreview())
         {
           newPreviewImage = Image::New();
           newPreviewImage->Initialize(workingImageBin);
         }
         else
         {
           auto newPreviewImage = workingImageBin->Clone();
         }
         if (newPreviewImage.IsNull())
         {
           MITK_ERROR << "Cannot create preview helper objects. Unable to clone working image";
           return;
         }
         m_PreviewSegmentationNode->SetData(newPreviewImage);
       }
       else
       {
         mitkThrow() << "Tool is an invalid state. Cannot setup preview node. Working data is an unsupported class and should have not been accepted by CanHandle().";
       }
     }
 
     m_PreviewSegmentationNode->SetColor(previewColor);
     m_PreviewSegmentationNode->SetOpacity(0.5);
 
     int layer(50);
     m_ReferenceDataNode->GetIntProperty("layer", layer);
     m_PreviewSegmentationNode->SetIntProperty("layer", layer + 1);
 
     if (DataStorage *ds = this->GetToolManager()->GetDataStorage())
     {
       if (!ds->Exists(m_PreviewSegmentationNode))
         ds->Add(m_PreviewSegmentationNode, m_ReferenceDataNode);
     }
   }
 }
 
-void mitk::AutoSegmentationWithPreviewTool::TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep)
+mitk::SegWithPreviewTool::LabelMappingType mitk::SegWithPreviewTool::GetLabelMapping() const
+{
+  LabelMappingType labelMapping = { { this->GetUserDefinedActiveLabel(),this->GetUserDefinedActiveLabel() } };
+  if (LabelTransferMode::SelectedLabels == this->m_LabelTransferMode)
+  {
+    labelMapping.clear();
+    for (auto label : this->m_SelectedLabels)
+    {
+      labelMapping.push_back({ label, label });
+    }
+  }
+  else if (LabelTransferMode::AllLabels == this->m_LabelTransferMode)
+  {
+    labelMapping.clear();
+    const auto labelSet = this->GetPreviewSegmentation()->GetActiveLabelSet();
+    for (auto labelIter = labelSet->IteratorConstBegin(); labelIter != labelSet->IteratorConstEnd(); ++labelIter)
+    {
+      labelMapping.push_back({ labelIter->second->GetValue(),labelIter->second->GetValue() });
+    }
+  }
+
+  return labelMapping;
+}
+
+void mitk::SegWithPreviewTool::TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep)
 {
   try
   {
     Image::ConstPointer sourceImageAtTimeStep = this->GetImageByTimeStep(sourceImage, timeStep);
 
     if (sourceImageAtTimeStep->GetPixelType() != destinationImage->GetPixelType())
     {
       mitkThrow() << "Cannot transfer images. Tool is in an invalid state, source image and destination image do not have the same pixel type. "
         << "Source pixel type: " << sourceImage->GetPixelType().GetTypeAsString()
         << "; destination pixel type: " << destinationImage->GetPixelType().GetTypeAsString();
     }
 
     if (!Equal(*(sourceImage->GetGeometry(timeStep)), *(destinationImage->GetGeometry(timeStep)), NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_COORDINATE_PRECISION, NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_DIRECTION_PRECISION, false))
     {
       mitkThrow() << "Cannot transfer images. Tool is in an invalid state, source image and destination image do not have the same geometry.";
     }
 
     if (nullptr != this->GetWorkingPlaneGeometry())
     {
       auto sourceSlice = SegTool2D::GetAffectedImageSliceAs2DImage(this->GetWorkingPlaneGeometry(), sourceImage, timeStep);
       SegTool2D::WriteBackSegmentationResult(this->GetTargetSegmentationNode(), m_WorkingPlaneGeometry, sourceSlice, timeStep);
     }
     else
     { //take care of the full segmentation volume
       auto sourceLSImage = dynamic_cast<const LabelSetImage*>(sourceImage);
       auto destLSImage = dynamic_cast<LabelSetImage*>(destinationImage);
 
-      TransferLabelContent(sourceLSImage, destLSImage, { {this->GetUserDefinedActiveLabel(),this->GetUserDefinedActiveLabel()} }, false, timeStep);
+      auto labelMapping = this->GetLabelMapping();
+      TransferLabelContent(sourceLSImage, destLSImage, labelMapping, m_MergeStyle, m_OverwriteStyle, timeStep);
     }
   }
   catch (...)
   {
     Tool::ErrorMessage("Error accessing single time steps of the original image. Cannot create segmentation.");
     throw;
   }
 }
 
-void mitk::AutoSegmentationWithPreviewTool::CreateResultSegmentationFromPreview()
+void mitk::SegWithPreviewTool::CreateResultSegmentationFromPreview()
 {
   const auto segInput = this->GetSegmentationInput();
   auto previewImage = this->GetPreviewSegmentation();
   if (nullptr != segInput && nullptr != previewImage)
   {
     DataNode::Pointer resultSegmentationNode = GetTargetSegmentationNode();
 
     if (resultSegmentationNode.IsNotNull())
     {
       const auto timePoint = RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
       auto resultSegmentation = dynamic_cast<Image*>(resultSegmentationNode->GetData());
 
       // REMARK: the following code in this scope assumes that previewImage and resultSegmentation
       // are clones of the working image (segmentation provided to the tool). Therefore they have
       // the same time geometry.
       if (previewImage->GetTimeSteps() != resultSegmentation->GetTimeSteps())
       {
-        mitkThrow() << "Cannot perform threshold. Internal tool state is invalid."
+        mitkThrow() << "Cannot confirm/transfer segmentation. Internal tool state is invalid."
           << " Preview segmentation and segmentation result image have different time geometries.";
       }
 
+      this->TransferPrepare();
       if (m_CreateAllTimeSteps)
       {
         for (unsigned int timeStep = 0; timeStep < previewImage->GetTimeSteps(); ++timeStep)
         {
           this->TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep);
         }
       }
       else
       {
         const auto timeStep = resultSegmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
         this->TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep);
       }
 
       // since we are maybe working on a smaller image, pad it to the size of the original image
       if (m_ReferenceDataNode.GetPointer() != m_SegmentationInputNode.GetPointer())
       {
         PadImageFilter::Pointer padFilter = PadImageFilter::New();
 
         padFilter->SetInput(0, resultSegmentation);
         padFilter->SetInput(1, dynamic_cast<Image*>(m_ReferenceDataNode->GetData()));
         padFilter->SetBinaryFilter(true);
         padFilter->SetUpperThreshold(1);
         padFilter->SetLowerThreshold(1);
         padFilter->Update();
 
         resultSegmentationNode->SetData(padFilter->GetOutput());
       }
-      if (m_OverwriteExistingSegmentation)
-      { //if we overwrite the segmentation (and not just store it as a new result
-        //in the data storage) we update also the tool manager state.
-        this->GetToolManager()->SetWorkingData(resultSegmentationNode);
-        this->GetToolManager()->GetWorkingData(0)->Modified();
-      }
       this->EnsureTargetSegmentationNodeInDataStorage();
     }
   }
 }
 
-void mitk::AutoSegmentationWithPreviewTool::OnRoiDataChanged()
+void mitk::SegWithPreviewTool::OnRoiDataChanged()
 {
   DataNode::ConstPointer node = this->GetToolManager()->GetRoiData(0);
 
   if (node.IsNotNull())
   {
     MaskAndCutRoiImageFilter::Pointer roiFilter = MaskAndCutRoiImageFilter::New();
     Image::Pointer image = dynamic_cast<Image *>(m_SegmentationInputNode->GetData());
 
     if (image.IsNull())
       return;
 
     roiFilter->SetInput(image);
     roiFilter->SetRegionOfInterest(node->GetData());
     roiFilter->Update();
 
     DataNode::Pointer tmpNode = DataNode::New();
     tmpNode->SetData(roiFilter->GetOutput());
 
     m_SegmentationInputNode = tmpNode;
   }
   else
     m_SegmentationInputNode = m_ReferenceDataNode;
 
   this->ResetPreviewNode();
   this->InitiateToolByInput();
   this->UpdatePreview();
 }
 
-void mitk::AutoSegmentationWithPreviewTool::OnTimePointChanged()
+void mitk::SegWithPreviewTool::OnTimePointChanged()
 {
   if (m_IsTimePointChangeAware && m_PreviewSegmentationNode.IsNotNull() && m_SegmentationInputNode.IsNotNull())
   {
     const auto timePoint = RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
     const bool isStaticSegOnDynamicImage = m_PreviewSegmentationNode->GetData()->GetTimeSteps() == 1 && m_SegmentationInputNode->GetData()->GetTimeSteps() > 1;
     if (timePoint!=m_LastTimePointOfUpdate && (isStaticSegOnDynamicImage || m_LazyDynamicPreviews))
     { //we only need to update either because we are lazzy
       //or because we have a static segmentation with a dynamic image 
       this->UpdatePreview();
     }
   }
 }
 
-bool mitk::AutoSegmentationWithPreviewTool::EnsureUpToDateUserDefinedActiveLabel()
+bool mitk::SegWithPreviewTool::EnsureUpToDateUserDefinedActiveLabel()
 {
   bool labelChanged = true;
 
   const auto workingImage = dynamic_cast<const Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
   if (const auto& labelSetImage = dynamic_cast<const LabelSetImage*>(workingImage))
   {
     // this is a fix for T28131 / T28986, which should be refactored if T28524 is being worked on
     auto newLabel = labelSetImage->GetActiveLabel(labelSetImage->GetActiveLayer())->GetValue();
     labelChanged = newLabel != m_UserDefinedActiveLabel;
     m_UserDefinedActiveLabel = newLabel;
   }
   else
   {
     m_UserDefinedActiveLabel = 1;
     labelChanged = false;
   }
   return labelChanged;
 }
 
-void mitk::AutoSegmentationWithPreviewTool::UpdatePreview(bool ignoreLazyPreviewSetting)
+void mitk::SegWithPreviewTool::UpdatePreview(bool ignoreLazyPreviewSetting)
 {
   const auto inputImage = this->GetSegmentationInput();
   auto previewImage = this->GetPreviewSegmentation();
   int progress_steps = 200;
 
   const auto workingImage = dynamic_cast<const Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
   this->EnsureUpToDateUserDefinedActiveLabel();
 
   this->CurrentlyBusy.Send(true);
   m_IsUpdating = true;
 
   this->UpdatePrepare();
 
   const auto timePoint = RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
   try
   {
     if (nullptr != inputImage && nullptr != previewImage)
     {
       m_ProgressCommand->AddStepsToDo(progress_steps);
 
       if (previewImage->GetTimeSteps() > 1 && (ignoreLazyPreviewSetting || !m_LazyDynamicPreviews))
       {
         for (unsigned int timeStep = 0; timeStep < previewImage->GetTimeSteps(); ++timeStep)
         {
           Image::ConstPointer feedBackImage;
           Image::ConstPointer currentSegImage;
 
           auto previewTimePoint = previewImage->GetTimeGeometry()->TimeStepToTimePoint(timeStep);
           auto inputTimeStep = inputImage->GetTimeGeometry()->TimePointToTimeStep(previewTimePoint);
 
           if (nullptr != this->GetWorkingPlaneGeometry())
           { //only extract a specific slice defined by the working plane as feedback image.
             feedBackImage = SegTool2D::GetAffectedImageSliceAs2DImage(this->GetWorkingPlaneGeometry(), inputImage, inputTimeStep);
             currentSegImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), workingImage, previewTimePoint);
           }
           else
           { //work on the whole feedback image
             feedBackImage = this->GetImageByTimeStep(inputImage, inputTimeStep);
             currentSegImage = this->GetImageByTimePoint(workingImage, previewTimePoint);
           }
 
           this->DoUpdatePreview(feedBackImage, currentSegImage, previewImage, timeStep);
         }
       }
       else
       {
         Image::ConstPointer feedBackImage;
         Image::ConstPointer currentSegImage;
 
         if (nullptr != this->GetWorkingPlaneGeometry())
         {
           feedBackImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), inputImage, timePoint);
           currentSegImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), workingImage, timePoint);
         }
         else
         {
           feedBackImage = this->GetImageByTimePoint(inputImage, timePoint);
           currentSegImage = this->GetImageByTimePoint(workingImage, timePoint);
         }
 
         auto timeStep = previewImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
 
         this->DoUpdatePreview(feedBackImage, currentSegImage, previewImage, timeStep);
       }
       RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
   catch (itk::ExceptionObject & excep)
   {
     MITK_ERROR << "Exception caught: " << excep.GetDescription();
 
     m_ProgressCommand->SetProgress(progress_steps);
 
     std::string msg = excep.GetDescription();
     ErrorMessage.Send(msg);
   }
   catch (...)
   {
     m_ProgressCommand->SetProgress(progress_steps);
     m_IsUpdating = false;
     CurrentlyBusy.Send(false);
     throw;
   }
 
   this->UpdateCleanUp();
   m_LastTimePointOfUpdate = timePoint;
   m_ProgressCommand->SetProgress(progress_steps);
   m_IsUpdating = false;
   CurrentlyBusy.Send(false);
 }
 
-bool mitk::AutoSegmentationWithPreviewTool::IsUpdating() const
+bool mitk::SegWithPreviewTool::IsUpdating() const
 {
   return m_IsUpdating;
 }
 
-void mitk::AutoSegmentationWithPreviewTool::UpdatePrepare()
+void mitk::SegWithPreviewTool::UpdatePrepare()
 {
   // default implementation does nothing
   //reimplement in derived classes for special behavior
 }
 
-void mitk::AutoSegmentationWithPreviewTool::UpdateCleanUp()
+void mitk::SegWithPreviewTool::UpdateCleanUp()
 {
   // default implementation does nothing
   //reimplement in derived classes for special behavior
 }
 
-mitk::TimePointType mitk::AutoSegmentationWithPreviewTool::GetLastTimePointOfUpdate() const
-{
-  return m_LastTimePointOfUpdate;
-}
-
-/** Functor class that implements the label transfer and is used in conjunction with the itk::BinaryFunctorImageFilter.
-* For details regarding the usage of the filter and the functor patterns, please see info of itk::BinaryFunctorImageFilter.
-*/
-template <class TDestinationPixel, class TSourcePixel, class TOutputpixel>
-class LabelTransferFunctor
+void mitk::SegWithPreviewTool::TransferLabelInformation(LabelMappingType& labelMapping,
+  const mitk::LabelSetImage* source, mitk::LabelSetImage* target)
 {
-
-public:
-  LabelTransferFunctor(){};
-
-  LabelTransferFunctor(const mitk::LabelSet* destinationLabelSet, mitk::Label::PixelType sourceBackground,
-    mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked,
-    mitk::Label::PixelType sourceLabel, mitk::Label::PixelType newDestinationLabel, bool mergeMode) :
-    m_DestinationLabelSet(destinationLabelSet), m_SourceBackground(sourceBackground),
-    m_DestinationBackground(destinationBackground), m_DestinationBackgroundLocked(destinationBackgroundLocked),
-    m_SourceLabel(sourceLabel), m_NewDestinationLabel(newDestinationLabel), m_MergeMode(mergeMode)
+  for (const auto& [sourceLabel, targetLabel] : labelMapping)
   {
-  };
-
-  ~LabelTransferFunctor() {};
+    if (!target->ExistLabel(targetLabel, target->GetActiveLayer()))
+    {
+      if (!source->ExistLabel(sourceLabel, source->GetActiveLayer()))
+      {
+        mitkThrow() << "Cannot prepare segmentation for preview transfer. Preview seems invalid as label is missing. Missing label: " << sourceLabel;
+      }
 
-  bool operator!=(const LabelTransferFunctor& other)const
-  {
-    return !(*this == other);
-  }
-  bool operator==(const LabelTransferFunctor& other) const
-  {
-    return this->m_SourceBackground == other.m_SourceBackground &&
-      this->m_DestinationBackground == other.m_DestinationBackground &&
-      this->m_DestinationBackgroundLocked == other.m_DestinationBackgroundLocked &&
-      this->m_SourceLabel == other.m_SourceLabel &&
-      this->m_NewDestinationLabel == other.m_NewDestinationLabel &&
-      this->m_MergeMode == other.m_MergeMode &&
-      this->m_DestinationLabelSet == other.m_DestinationLabelSet;
+      auto clonedLabel = source->GetLabel(sourceLabel, source->GetActiveLayer())->Clone();
+      clonedLabel->SetValue(targetLabel);
+      target->GetActiveLabelSet()->AddLabel(clonedLabel);
+    }
   }
+}
 
-  LabelTransferFunctor& operator=(const LabelTransferFunctor& other)
-  {
-    this->m_DestinationLabelSet = other.m_DestinationLabelSet;
-    this->m_SourceBackground = other.m_SourceBackground;
-    this->m_DestinationBackground = other.m_DestinationBackground;
-    this->m_DestinationBackgroundLocked = other.m_DestinationBackgroundLocked;
-    this->m_SourceLabel = other.m_SourceLabel;
-    this->m_NewDestinationLabel = other.m_NewDestinationLabel;
-    this->m_MergeMode = other.m_MergeMode;
+void mitk::SegWithPreviewTool::TransferPrepare()
+{
+  auto labelMapping = this->GetLabelMapping();
 
-    return *this;
-  }
+  DataNode::Pointer resultSegmentationNode = GetTargetSegmentationNode();
 
-  inline TOutputpixel operator()(const TDestinationPixel& existingDestinationValue, const TSourcePixel& existingSourceValue)
+  if (resultSegmentationNode.IsNotNull())
   {
-    if (existingSourceValue == this->m_SourceLabel
-      && !this->m_DestinationLabelSet->GetLabel(existingDestinationValue)->GetLocked())
-    {
-      return this->m_NewDestinationLabel;
-    }
-    else if (!this->m_MergeMode
-      && existingSourceValue == this->m_SourceBackground
-      && existingDestinationValue == this->m_NewDestinationLabel
-      && !this->m_DestinationBackgroundLocked)
+    auto resultSegmentation = dynamic_cast<LabelSetImage*>(resultSegmentationNode->GetData());
+
+    if (nullptr == resultSegmentation)
     {
-      return this->m_DestinationBackground;
+      mitkThrow() << "Cannot prepare segmentation for preview transfer. Tool is in invalid state as segmentation is not existing or of right type";
     }
 
-    return existingDestinationValue;
+    auto preview = this->GetPreviewSegmentation();
+    TransferLabelInformation(labelMapping, preview, resultSegmentation);
   }
+}
 
-private:
-  const mitk::LabelSet* m_DestinationLabelSet = nullptr;
-  mitk::Label::PixelType m_SourceBackground = 0;
-  mitk::Label::PixelType m_DestinationBackground = 0;
-  bool m_DestinationBackgroundLocked = false;
-  mitk::Label::PixelType m_SourceLabel = 1;
-  mitk::Label::PixelType m_NewDestinationLabel = 1;
-  bool m_MergeMode = false;
-};
-
-/**Helper function used by TransferLabelContent to allow the templating over different image dimensions in conjunction of AccessFixedPixelTypeByItk_n.*/
-template<unsigned int VImageDimension>
-void TransferLabelContentHelper(const itk::Image<mitk::Label::PixelType, VImageDimension>* itkSourceImage, mitk::Image* destinationImage, const mitk::LabelSet* destinationLabelSet, mitk::Label::PixelType sourceBackground, mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked, mitk::Label::PixelType sourceLabel, mitk::Label::PixelType newDestinationLabel, bool mergeMode)
+mitk::TimePointType mitk::SegWithPreviewTool::GetLastTimePointOfUpdate() const
 {
-  typedef itk::Image<mitk::Label::PixelType, VImageDimension> ContentImageType;
-  typename ContentImageType::Pointer itkDestinationImage;
-  mitk::CastToItkImage(destinationImage, itkDestinationImage);
-
-  typedef LabelTransferFunctor <mitk::Label::PixelType, mitk::Label::PixelType, mitk::Label::PixelType> LabelTransferFunctorType;
-  typedef itk::BinaryFunctorImageFilter<ContentImageType, ContentImageType, ContentImageType, LabelTransferFunctorType> FilterType;
+  return m_LastTimePointOfUpdate;
+}
 
-  LabelTransferFunctorType transferFunctor(destinationLabelSet, sourceBackground, destinationBackground,
-    destinationBackgroundLocked, sourceLabel, newDestinationLabel, mergeMode);
+const char* mitk::SegWithPreviewTool::GetGroup() const
+{
+  return "autoSegmentation";
+}
 
-  auto transferFilter = FilterType::New();
+mitk::Image::ConstPointer mitk::SegWithPreviewTool::GetImageByTimeStep(const mitk::Image* image, TimeStepType timestep)
+{
+  return SelectImageByTimeStep(image, timestep);
+}
 
-  transferFilter->SetFunctor(transferFunctor);
-  transferFilter->InPlaceOn();
-  transferFilter->SetInput1(itkDestinationImage);
-  transferFilter->SetInput2(itkSourceImage);
+mitk::Image::Pointer mitk::SegWithPreviewTool::GetImageByTimeStep(mitk::Image* image, TimeStepType timestep)
+{
+  return SelectImageByTimeStep(image, timestep);
+}
 
-  transferFilter->Update();
+mitk::Image::ConstPointer mitk::SegWithPreviewTool::GetImageByTimePoint(const mitk::Image* image, TimePointType timePoint)
+{
+  return SelectImageByTimeStep(image, timePoint);
 }
 
-void mitk::AutoSegmentationWithPreviewTool::TransferLabelContent(
-  const LabelSetImage* sourceImage, LabelSetImage* destinationImage, std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping, bool mergeMode, const TimeStepType timeStep)
+void mitk::SegWithPreviewTool::EnsureTargetSegmentationNodeInDataStorage() const
 {
-  if (nullptr == sourceImage)
-  {
-    mitkThrow() << "Invalid call of TransferLabelContent; sourceImage must not be null.";
-  }
-  if (nullptr == destinationImage)
+  auto targetNode = this->GetTargetSegmentationNode();
+  auto dataStorage = this->GetToolManager()->GetDataStorage();
+  if (!dataStorage->Exists(targetNode))
   {
-    mitkThrow() << "Invalid call of TransferLabelContent; destinationImage must not be null.";
+    dataStorage->Add(targetNode, this->GetToolManager()->GetReferenceData(0));
   }
+}
 
-  const auto sourceBackground = sourceImage->GetExteriorLabel()->GetValue();
-  const auto destinationBackground = destinationImage->GetExteriorLabel()->GetValue();
-  const auto destinationBackgroundLocked = destinationImage->GetExteriorLabel()->GetLocked();
-  const auto destinationLabelSet = destinationImage->GetLabelSet(destinationImage->GetActiveLayer());
+std::string mitk::SegWithPreviewTool::GetCurrentSegmentationName()
+{
+  auto workingData = this->GetToolManager()->GetWorkingData(0);
 
-  Image::ConstPointer sourceImageAtTimeStep = this->GetImageByTimeStep(sourceImage, timeStep);
-  Image::Pointer destinationImageAtTimeStep = this->GetImageByTimeStep(destinationImage, timeStep);
+  return nullptr != workingData
+    ? workingData->GetName()
+    : "";
+}
 
-  if (nullptr == sourceImageAtTimeStep)
-  {
-    mitkThrow() << "Invalid call of TransferLabelContent; sourceImage does not have the requested time step: "<<timeStep;
-  }
-  if (nullptr == destinationImageAtTimeStep)
-  {
-    mitkThrow() << "Invalid call of TransferLabelContent; destinationImage does not have the requested time step: " << timeStep;
-  }
 
-  for (const auto& [sourceLabel, newDestinationLabel] : labelMapping)
-  {
-    if (!sourceImage->ExistLabel(sourceLabel, sourceImage->GetActiveLayer()))
-    {
-      mitkThrow() << "Invalid call of TransferLabelContent. Defined source label does not exist in sourceImage. SourceLabel: "<<sourceLabel;
-    }
-    if (!destinationImage->ExistLabel(newDestinationLabel, destinationImage->GetActiveLayer()))
-    {
-      mitkThrow() << "Invalid call of TransferLabelContent. Defined destination label does not exist in destinationImage. newDestinationLabel: " << newDestinationLabel;
-    }
+mitk::DataNode* mitk::SegWithPreviewTool::GetTargetSegmentationNode() const
+{
+  return this->GetToolManager()->GetWorkingData(0);
+}
 
+void mitk::SegWithPreviewTool::TransferLabelSetImageContent(const LabelSetImage* source, LabelSetImage* target, TimeStepType timeStep)
+{
+  mitk::ImageReadAccessor newMitkImgAcc(source);
 
-    AccessFixedPixelTypeByItk_n(sourceImageAtTimeStep, TransferLabelContentHelper, (Label::PixelType), (destinationImageAtTimeStep, destinationLabelSet, sourceBackground, destinationBackground, destinationBackgroundLocked, sourceLabel, newDestinationLabel, mergeMode));
+  LabelMappingType labelMapping;
+  const auto labelSet = source->GetActiveLabelSet();
+  for (auto labelIter = labelSet->IteratorConstBegin(); labelIter != labelSet->IteratorConstEnd(); ++labelIter)
+  {
+    labelMapping.push_back({ labelIter->second->GetValue(),labelIter->second->GetValue() });
   }
-  destinationImage->Modified();
+  TransferLabelInformation(labelMapping, source, target);
+
+  target->SetVolume(newMitkImgAcc.GetData(), timeStep);
 }
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h b/Modules/Segmentation/Interactions/mitkSegWithPreviewTool.h
similarity index 63%
rename from Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
rename to Modules/Segmentation/Interactions/mitkSegWithPreviewTool.h
index a7af6f020b..b9462aa25e 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
+++ b/Modules/Segmentation/Interactions/mitkSegWithPreviewTool.h
@@ -1,231 +1,287 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
-#ifndef mitkAutoSegmentationWithPreviewTool_h_Included
-#define mitkAutoSegmentationWithPreviewTool_h_Included
+#ifndef mitkSegWithPreviewTool_h_Included
+#define mitkSegWithPreviewTool_h_Included
 
-#include "mitkAutoSegmentationTool.h"
+#include "mitkTool.h"
 #include "mitkCommon.h"
 #include "mitkDataNode.h"
 #include "mitkToolCommand.h"
 #include <MitkSegmentationExports.h>
 
 namespace mitk
 {
   /**
   \brief Base class for any auto segmentation tool that provides a preview of the new segmentation.
 
   This tool class implements a lot basic logic to handle auto segmentation tools with preview,
   Time point and ROI support. Derived classes will ask to update the segmentation preview if needed
   (e.g. because the ROI or the current time point has changed) or because derived tools
   indicated the need to update themselves.
   This class also takes care to properly transfer a confirmed preview into the segementation
   result.
 
   \ingroup ToolManagerEtAl
   \sa mitk::Tool
   \sa QmitkInteractiveSegmentation
   */
-  class MITKSEGMENTATION_EXPORT AutoSegmentationWithPreviewTool : public AutoSegmentationTool
+  class MITKSEGMENTATION_EXPORT SegWithPreviewTool : public Tool
   {
   public:
 
-    mitkClassMacro(AutoSegmentationWithPreviewTool, AutoSegmentationTool);
+    mitkClassMacro(SegWithPreviewTool, Tool);
 
     void Activated() override;
     void Deactivated() override;
 
     void ConfirmSegmentation();
 
     itkSetMacro(CreateAllTimeSteps, bool);
     itkGetMacro(CreateAllTimeSteps, bool);
     itkBooleanMacro(CreateAllTimeSteps);
 
     itkSetMacro(KeepActiveAfterAccept, bool);
     itkGetMacro(KeepActiveAfterAccept, bool);
     itkBooleanMacro(KeepActiveAfterAccept);
 
     itkSetMacro(IsTimePointChangeAware, bool);
     itkGetMacro(IsTimePointChangeAware, bool);
     itkBooleanMacro(IsTimePointChangeAware);
 
     itkSetMacro(ResetsToEmptyPreview, bool);
     itkGetMacro(ResetsToEmptyPreview, bool);
     itkBooleanMacro(ResetsToEmptyPreview);
 
+    /*itk macro was not used on purpose, to aviod the change of mtime.*/
+    void SetMergeStyle(MultiLabelSegmentation::MergeStyle mergeStyle);
+    itkGetMacro(MergeStyle, MultiLabelSegmentation::MergeStyle);
+
+    /*itk macro was not used on purpose, to aviod the change of mtime.*/
+    void SetOverwriteStyle(MultiLabelSegmentation::OverwriteStyle overwriteStyle);
+    itkGetMacro(OverwriteStyle, MultiLabelSegmentation::OverwriteStyle);
+
+    enum class LabelTransferMode
+    {
+      ActiveLabel, //Only the active label will be transfered from preview to segmentation.
+      SelectedLabels, //The labels defined as selected labels will be transfered.
+      AllLabels //Transfer all labels of the preview
+    };
+    /*itk macro was not used on purpose, to aviod the change of mtime.*/
+    void SetLabelTransferMode(LabelTransferMode LabelTransferMode);
+    itkGetMacro(LabelTransferMode, LabelTransferMode);
+
+    using SelectedLabelVectorType = std::vector<Label::PixelType>;
+    /** Specifies the labels that should be transfered form preview to the working image,
+      if the segmentation is confirmed. The setting will be used, if LabelTransferMode is set to "SelectedLabels".*/
+    void SetSelectedLabels(const SelectedLabelVectorType& labelsToTransfer);
+    itkGetMacro(SelectedLabels, SelectedLabelVectorType);
+
     bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
 
     /** Triggers the actualization of the preview
      * @param ignoreLazyPreviewSetting If set true UpdatePreview will always
      * generate the preview for all time steps. If set to false, UpdatePreview
      * will regard the setting specified by the constructor.
      * To define the update generation for time steps implement DoUpdatePreview.
      * To alter what should be done directly before or after the update of the preview,
      * reimplement UpdatePrepare() or UpdateCleanUp().*/
     void UpdatePreview(bool ignoreLazyPreviewSetting = false);
 
     /** Indicate if currently UpdatePreview is triggered (true) or not (false).*/
     bool IsUpdating() const;
 
+    /**
+   * @brief Gets the name of the currently selected segmentation node
+   * @return the name of the segmentation node or an empty string if
+   *         none is selected
+   */
+    std::string GetCurrentSegmentationName();
+
+    /**
+     * @brief Returns the currently selected segmentation node
+     * @return a mitk::DataNode which contains a segmentation image
+     */
+    virtual DataNode* GetTargetSegmentationNode() const;
+
+    /** Returns the image that contains the preview of the current segmentation.
+     * Returns null if the node is not set or does not contain an image.*/
+    LabelSetImage* GetPreviewSegmentation();
+    const LabelSetImage* GetPreviewSegmentation() const;
+    DataNode* GetPreviewSegmentationNode();
+
   protected:
     ToolCommand::Pointer m_ProgressCommand;
 
+    SegWithPreviewTool(bool lazyDynamicPreviews = false); // purposely hidden
+    SegWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule = nullptr); // purposely hidden
+
+    ~SegWithPreviewTool() override;
+
+    const char* GetGroup() const override;
+
+    /** Helper that extracts the image for the passed timestep, if the image has multiple time steps.*/
+    static Image::ConstPointer GetImageByTimeStep(const Image* image, TimeStepType timestep);
+    /** Helper that extracts the image for the passed timestep, if the image has multiple time steps.*/
+    static Image::Pointer GetImageByTimeStep(Image* image, TimeStepType timestep);
+    /** Helper that extracts the image for the passed time point, if the image has multiple time steps.*/
+    static Image::ConstPointer GetImageByTimePoint(const Image* image, TimePointType timePoint);
+
+    void EnsureTargetSegmentationNodeInDataStorage() const;
+
     /** Member is always called if GetSegmentationInput() has changed
      * (e.g. because a new ROI was defined, or on activation) to give derived
      * classes the posibility to initiate their state accordingly.
      * Reimplement this function to implement special behavior.
      */
     virtual void InitiateToolByInput();
 
     /** This member function offers derived classes the possibility to alter what should
     happen directly before the update of the preview is performed. It is called by
     UpdatePreview. Default implementation does nothing.*/
     virtual void UpdatePrepare();
 
     /** This member function offers derived classes the possibility to alter what should
     happen directly after the update of the preview is performed. It is called by
     UpdatePreview. Default implementation does nothing.*/
     virtual void UpdateCleanUp();
 
+    /** This member function offers derived classes the possibility to alter what should
+    happen directly before the content of the preview is transfered to the segmentation,
+    when the segmentation is confirmed. It is called by CreateResultSegmentationFromPreview.
+    Default implementation ensure that all labels that will be transfered, exist in the
+    segmentation. If they are not existing before the transfer, the will be added by
+    cloning the label information of the preview.*/
+    virtual void TransferPrepare();
+
+    using LabelMappingType = std::vector<std::pair<Label::PixelType, Label::PixelType> >;
+    static void TransferLabelInformation(LabelMappingType& labelMapping,
+      const mitk::LabelSetImage* source, mitk::LabelSetImage* target);
+
+    /**Helper function that can be used to move the content of an LabelSetImage (the pixels of the active source layer and the labels).
+     This is e.g. helpfull if you generate an LabelSetImage content in DoUpdatePreview and you want to transfer it into the preview image.*/
+    static void TransferLabelSetImageContent(const LabelSetImage* source, LabelSetImage* target, TimeStepType timeStep);
+
     /** This function does the real work. Here the preview for a given
      * input image should be computed and stored in the also passed
      * preview image at the passed time step.
      * It also provides the current/old segmentation at the time point,
      * which can be used, if the preview depends on the the segmenation so far.
      */
-    virtual void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep) = 0;
-
-    AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews = false); // purposely hidden
-    AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule = nullptr); // purposely hidden
-
-    ~AutoSegmentationWithPreviewTool() override;
-
-    /** Returns the image that contains the preview of the current segmentation.
-     * Returns null if the node is not set or does not contain an image.*/
-    Image* GetPreviewSegmentation();
-    DataNode* GetPreviewSegmentationNode();
+    virtual void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep) = 0;
 
     /** Returns the input that should be used for any segmentation/preview or tool update.
      * It is either the data of ReferenceDataNode itself or a part of it defined by a ROI mask
      * provided by the tool manager. Derived classes should regard this as the relevant
      * input data for any processing.
      * Returns null if the node is not set or does not contain an image.*/
     const Image* GetSegmentationInput() const;
 
     /** Returns the image that is provided by the ReferenceDataNode.
      * Returns null if the node is not set or does not contain an image.*/
     const Image* GetReferenceData() const;
 
     /** Resets the preview node so it is empty and ready to be filled by the tool
     @remark Calling this function will generate a new preview image, and the old
     might be invalidated. Therefore this function should not be used within the
     scope of UpdatePreview (m_IsUpdating == true).*/
     void ResetPreviewNode();
 
     /** Resets the complete content of the preview image. The instance of the preview image and its settings
     * stay the same.*/
     void ResetPreviewContent();
 
     /** Resets only the image content of the specified timeStep of the preview image. If the preview image or the specified
     time step does not exist, nothing happens.*/
     void ResetPreviewContentAtTimeStep(unsigned int timeStep);
 
     TimePointType GetLastTimePointOfUpdate() const;
 
     itkGetConstMacro(UserDefinedActiveLabel, Label::PixelType);
 
     itkSetObjectMacro(WorkingPlaneGeometry, PlaneGeometry);
     itkGetConstObjectMacro(WorkingPlaneGeometry, PlaneGeometry);
 
   private:
     void TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep);
 
-    /**Helper function that transfers pixels of the specified source label from source image to the destination image by using
-    a specified destination label. Function processes the whole image volume of the specified time step.
-    @remark in its current implementation the function only transfers contents of the active layer of the passed LabelSetImages.
-    @remark the function assumes that it is only called with source and destination image of same geometry.
-    @param sourceImage Pointer to the LabelSetImage which active layer should be used as source for the transfer.
-    @param destionationImage Pointer to the LabelSetImage which active layer should be used as destination for the transfer.
-    @param labelMapping Map that encodes the mappings of all label pixel transfers that should be done. First element is the
-    label in the source image. The second element is the label that transferred pixels should become in the destination image.
-    @param mergeMode indicates how the transfer should be done. If true, it is performed like a merge/union operation. So only
-    pixels of the label will be added. If false, also background is transferred, if present in the source image where the
-    destinationImage is labeled by the destination label. Therefore in this mode the label in the destinationImage can
-    "shrink"/lose pixels to the background.
-    @param timeStep indicate the time step that should be transferred.
-    @pre sourceImage and destinationImage must be valid
-    @pre sourceImage and destinationImage must contain the indicated timeStep
-    @pre sourceImage must contain all indicated sourceLabels in its active layer.
-    @pre destinationImage must contain all indicated destinationLabels in its active layer.*/
-    void TransferLabelContent(const LabelSetImage* sourceImage, LabelSetImage* destinationImage,
-      std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping = { {1,1} },
-      bool mergeMode = false, const TimeStepType timeStep = 0);
-
     void CreateResultSegmentationFromPreview();
 
     void OnRoiDataChanged();
     void OnTimePointChanged();
 
     /**Internal helper that ensures that the stored active label is up to date.
      This is a fix for T28131 / T28986. It should be refactored if T28524 is being worked on.
      On the long run, the active label will be communicated/set by the user/toolmanager as a
      state of the tool and the tool should react accordingly (like it does for other external
      state changes).
      @return indicates if the label has changed (true) or not.
      */
     bool EnsureUpToDateUserDefinedActiveLabel();
 
+    LabelMappingType GetLabelMapping() const;
+
     /** Node that containes the preview data generated and managed by this class or derived ones.*/
     DataNode::Pointer m_PreviewSegmentationNode;
     /** The reference data recieved from ToolManager::GetReferenceData when tool was activated.*/
     DataNode::Pointer m_ReferenceDataNode;
     /** Node that containes the data that should be used as input for any auto segmentation. It might
      * be the same like m_ReferenceDataNode (if no ROI is set) or a sub region (if ROI is set).*/
     DataNode::Pointer m_SegmentationInputNode;
 
     /** Indicates if Accepting the threshold should transfer/create the segmentations
      of all time steps (true) or only of the currently selected timepoint (false).*/
     bool m_CreateAllTimeSteps = false;
 
     /** Indicates if the tool should kept active after accepting the segmentation or not.*/
     bool m_KeepActiveAfterAccept = false;
 
     /** Relevant if the working data / preview image has multiple time steps (dynamic segmentations).
      * This flag has to be set by derived classes accordingly to there way to generate dynamic previews.
      * If LazyDynamicPreview is true, the tool generates only the preview for the current time step.
      * Therefore it always has to update the preview if current time point has changed and it has to (re)compute
      * all timeframes if ConfirmSegmentation() is called.*/
     bool m_LazyDynamicPreviews = false;
 
     bool m_IsTimePointChangeAware = true;
 
     /** Controls if ResetPreviewNode generates an empty content (true) or clones the current
     segmentation (false).*/
     bool m_ResetsToEmptyPreview = false;
 
     TimePointType m_LastTimePointOfUpdate = 0.;
 
     bool m_IsUpdating = false;
 
     Label::PixelType m_UserDefinedActiveLabel = 1;
 
     /** This variable indicates if for the tool a working plane geometry is defined.
      * If a working plane is defined the tool will only work an the slice of the input
      * and the segmentation. Thus only the relevant input slice will be passed to
      * DoUpdatePreview(...) and only the relevant slice of the preview will be transfered when
      * ConfirmSegmentation() is called.*/
     PlaneGeometry::Pointer m_WorkingPlaneGeometry;
+
+    /** This variable controles how the label pixel content of the preview should be transfered into the
+      segmentation- For more details of the behavior see documentation of MultiLabelSegmentation::MergeStyle. */
+    MultiLabelSegmentation::MergeStyle m_MergeStyle = MultiLabelSegmentation::MergeStyle::Replace;
+    /** This variable controles how the label pixel content of the preview should be transfered into the
+      segmentation- For more details of the behavior see documentation of MultiLabelSegmentation::OverwriteStyle. */
+    MultiLabelSegmentation::OverwriteStyle m_OverwriteStyle = MultiLabelSegmentation::OverwriteStyle::RegardLocks;
+
+    LabelTransferMode m_LabelTransferMode = LabelTransferMode::ActiveLabel;
+    SelectedLabelVectorType m_SelectedLabels = {};
   };
 
 } // namespace
 
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkSegmentationInteractor.cpp b/Modules/Segmentation/Interactions/mitkSegmentationInteractor.cpp
index f14f92c7a4..5cbc3921b9 100644
--- a/Modules/Segmentation/Interactions/mitkSegmentationInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegmentationInteractor.cpp
@@ -1,65 +1,64 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkSegmentationInteractor.h"
 #include "mitkInteractionPositionEvent.h"
 #include "mitkLabelSetImage.h"
 #include "mitkToolManager.h"
 #include "mitkToolManagerProvider.h"
 #include <mitkImagePixelReadAccessor.h>
 
 #include <cstring>
 
 void mitk::SegmentationInteractor::ConnectActionsAndFunctions()
 {
   Superclass::ConnectActionsAndFunctions();
 
   // CONNECT_FUNCTION("change_active_label", ChangeActiveLabel);
 }
 
 bool mitk::SegmentationInteractor::ChangeActiveLabel(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   BaseRenderer::Pointer sender = interactionEvent->GetSender();
   auto positionEvent = static_cast<InteractionPositionEvent*>(interactionEvent);
 
-  auto toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(
-    mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
+  auto toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
 
   assert(toolManager);
 
   DataNode *workingNode(toolManager->GetWorkingData(0));
   if (workingNode && positionEvent)
   {
     //TODO T28561
     //Code uses a deprecated method. deactivated whole code until the refactorization is done.
     throw "TODO T28561. Was forgot to refactor in context of T28524. The new MultiLabelSegmentation class will have a dedicated function for querying the label of world position.";
 
     //auto *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
     //assert(workingImage);
 
     //const auto timestep = positionEvent->GetSender()->GetTimeStep(workingImage);
 
    //int pixelValue = static_cast<int>(workingImage->GetPixelValueByWorldCoordinate(positionEvent->GetPositionInWorld(), timestep));
     //workingImage->GetActiveLabelSet()->SetActiveLabel(pixelValue); // can be the background
 
     // // Call Events
     // // workingImage->ActiveLabelEvent.Send(pixelValue);
 
     // // MLI TODO
     // // toolManager->WorkingDataModified.Send();
 
     //TODO END Refactor with T28524
   }
 
   RenderingManager::GetInstance()->RequestUpdateAll();
   return true;
 }
diff --git a/Modules/Segmentation/Interactions/mitknnUnetTool.cpp b/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
index 99779403d0..1245ee2124 100644
--- a/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
+++ b/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
@@ -1,327 +1,320 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitknnUnetTool.h"
 
 #include "mitkIOUtil.h"
 #include "mitkProcessExecutor.h"
 #include <itksys/SystemTools.hxx>
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, nnUNetTool, "nnUNet tool");
 }
 
 mitk::nnUNetTool::nnUNetTool()
 {
   this->SetMitkTempDir(IOUtil::CreateTemporaryDirectory("mitk-XXXXXX"));
 }
 
 mitk::nnUNetTool::~nnUNetTool()
 {
   itksys::SystemTools::RemoveADirectory(this->GetMitkTempDir());
 }
 
 void mitk::nnUNetTool::Activated()
 {
   Superclass::Activated();
+  this->SetLabelTransferMode(LabelTransferMode::AllLabels);
 }
 
 void mitk::nnUNetTool::RenderOutputBuffer()
 {
   if (m_OutputBuffer != nullptr)
   {
-    Superclass::SetNodeProperties(m_OutputBuffer);
     try
     {
       if (nullptr != this->GetPreviewSegmentationNode())
       {
-        this->GetPreviewSegmentationNode()->SetVisibility(!this->GetSelectedLabels().empty());
-      }
-      if (this->GetSelectedLabels().empty())
-      {
-        this->ResetPreviewNode();
+        auto previewImage = this->GetPreviewSegmentation();
+        previewImage->InitializeByLabeledImage(m_OutputBuffer);
       }
     }
     catch (const mitk::Exception &e)
     {
       MITK_INFO << e.GetDescription();
     }
   }
 }
 
 void mitk::nnUNetTool::SetOutputBuffer(LabelSetImage::Pointer segmentation)
 {
   m_OutputBuffer = segmentation;
 }
 
 mitk::LabelSetImage::Pointer mitk::nnUNetTool::GetOutputBuffer()
 {
   return m_OutputBuffer;
 }
 
 void mitk::nnUNetTool::ClearOutputBuffer()
 {
   m_OutputBuffer = nullptr;
 }
 
 us::ModuleResource mitk::nnUNetTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("AI_48x48.png");
   return resource;
 }
 
 const char **mitk::nnUNetTool::GetXPM() const
 {
   return nullptr;
 }
 
 const char *mitk::nnUNetTool::GetName() const
 {
   return "nnUNet";
 }
 
 mitk::DataStorage *mitk::nnUNetTool::GetDataStorage()
 {
   return this->GetToolManager()->GetDataStorage();
 }
 
 mitk::DataNode *mitk::nnUNetTool::GetRefNode()
 {
   return this->GetToolManager()->GetReferenceData(0);
 }
 
 namespace
 {
   void onPythonProcessEvent(itk::Object * /*pCaller*/, const itk::EventObject &e, void *)
   {
     std::string testCOUT;
     std::string testCERR;
     const auto *pEvent = dynamic_cast<const mitk::ExternalProcessStdOutEvent *>(&e);
 
     if (pEvent)
     {
       testCOUT = testCOUT + pEvent->GetOutput();
       MITK_INFO << testCOUT;
     }
 
     const auto *pErrEvent = dynamic_cast<const mitk::ExternalProcessStdErrEvent *>(&e);
 
     if (pErrEvent)
     {
       testCERR = testCERR + pErrEvent->GetOutput();
       MITK_ERROR << testCERR;
     }
   }
 } // namespace
 
-mitk::LabelSetImage::Pointer mitk::nnUNetTool::ComputeMLPreview(const Image *inputAtTimeStep, TimeStepType /*timeStep*/)
+void mitk::nnUNetTool::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, LabelSetImage* previewImage, TimeStepType /*timeStep*/)
 {
-  if (m_InputBuffer == inputAtTimeStep)
-  {
-    return m_OutputBuffer;
-  }
   std::string inDir, outDir, inputImagePath, outputImagePath, scriptPath;
 
   ProcessExecutor::Pointer spExec = ProcessExecutor::New();
   itk::CStyleCommand::Pointer spCommand = itk::CStyleCommand::New();
   spCommand->SetCallback(&onPythonProcessEvent);
   spExec->AddObserver(ExternalProcessOutputEvent(), spCommand);
   ProcessExecutor::ArgumentListType args;
 
   inDir = IOUtil::CreateTemporaryDirectory("nnunet-in-XXXXXX", this->GetMitkTempDir());
   std::ofstream tmpStream;
   inputImagePath = IOUtil::CreateTemporaryFile(tmpStream, m_TEMPLATE_FILENAME, inDir + IOUtil::GetDirectorySeparator());
   tmpStream.close();
   std::size_t found = inputImagePath.find_last_of(IOUtil::GetDirectorySeparator());
   std::string fileName = inputImagePath.substr(found + 1);
   std::string token = fileName.substr(0, fileName.find("_"));
 
   if (this->GetNoPip())
   {
     scriptPath = this->GetnnUNetDirectory() + IOUtil::GetDirectorySeparator() + "nnunet" +
                  IOUtil::GetDirectorySeparator() + "inference" + IOUtil::GetDirectorySeparator() + "predict_simple.py";
   }
 
   try
   {
     if (this->GetMultiModal())
     {
       const std::string fileFormat(".nii.gz");
       const std::string fileNamePart("_000_000");
       std::string outModalFile;
       size_t len = inDir.length() + 1 + token.length() + fileNamePart.length() + 1 + fileFormat.length();
       outModalFile.reserve(len); // The 1(s) indicates a directory separator char and an underscore.
       for (size_t i = 0; i < m_OtherModalPaths.size(); ++i)
       {
         mitk::Image::ConstPointer modalImage = m_OtherModalPaths[i];
         outModalFile.append(inDir);
         outModalFile.push_back(IOUtil::GetDirectorySeparator());
         outModalFile.append(token);
         outModalFile.append(fileNamePart);
         outModalFile.append(std::to_string(i));
         outModalFile.append(fileFormat);
         IOUtil::Save(modalImage.GetPointer(), outModalFile);
         outModalFile.clear();
       }
     }
     else
     {
       IOUtil::Save(inputAtTimeStep, inputImagePath);
     }
   }
   catch (const mitk::Exception &e)
   {
     /*
     Can't throw mitk exception to the caller. Refer: T28691
     */
     MITK_ERROR << e.GetDescription();
-    return nullptr;
+    return;
   }
   // Code calls external process
   std::string command = "nnUNet_predict";
   if (this->GetNoPip())
   {
 #ifdef _WIN32
     command = "python";
 #else
     command = "python3";
 #endif
   }
   for (ModelParams &modelparam : m_ParamQ)
   {
     outDir = IOUtil::CreateTemporaryDirectory("nnunet-out-XXXXXX", this->GetMitkTempDir());
     outputImagePath = outDir + IOUtil::GetDirectorySeparator() + token + "_000.nii.gz";
     modelparam.outputDir = outDir;
     args.clear();
     if (this->GetNoPip())
     {
       args.push_back(scriptPath);
     }
     args.push_back("-i");
     args.push_back(inDir);
 
     args.push_back("-o");
     args.push_back(outDir);
 
     args.push_back("-t");
     args.push_back(modelparam.task);
 
     if (modelparam.model.find("cascade") != std::string::npos)
     {
       args.push_back("-ctr");
     }
     else
     {
       args.push_back("-tr");
     }
     args.push_back(modelparam.trainer);
 
     args.push_back("-m");
     args.push_back(modelparam.model);
 
     args.push_back("-p");
     args.push_back(modelparam.planId);
 
     if (!modelparam.folds.empty())
     {
       args.push_back("-f");
       for (auto fold : modelparam.folds)
       {
         args.push_back(fold);
       }
     }
 
     args.push_back("--num_threads_nifti_save");
     args.push_back("1"); // fixing to 1
 
     if (!this->GetMirror())
     {
       args.push_back("--disable_tta");
     }
 
     if (!this->GetMixedPrecision())
     {
       args.push_back("--disable_mixed_precision");
     }
 
     if (this->GetEnsemble())
     {
       args.push_back("--save_npz");
     }
 
     try
     {
       std::string resultsFolderEnv = "RESULTS_FOLDER=" + this->GetModelDirectory();
       itksys::SystemTools::PutEnv(resultsFolderEnv.c_str());
       std::string cudaEnv = "CUDA_VISIBLE_DEVICES=" + std::to_string(this->GetGpuId());
       itksys::SystemTools::PutEnv(cudaEnv.c_str());
 
       spExec->Execute(this->GetPythonPath(), command, args);
     }
     catch (const mitk::Exception &e)
     {
       /*
       Can't throw mitk exception to the caller. Refer: T28691
       */
       MITK_ERROR << e.GetDescription();
-      return nullptr;
+      return;
     }
   }
   if (this->GetEnsemble() && !this->GetPostProcessingJsonDirectory().empty())
   {
     args.clear();
     command = "nnUNet_ensemble";
     outDir = IOUtil::CreateTemporaryDirectory("nnunet-ensemble-out-XXXXXX", this->GetMitkTempDir());
     outputImagePath = outDir + IOUtil::GetDirectorySeparator() + token + "_000.nii.gz";
 
     args.push_back("-f");
     for (ModelParams &modelparam : m_ParamQ)
     {
       args.push_back(modelparam.outputDir);
     }
 
     args.push_back("-o");
     args.push_back(outDir);
 
     if (!this->GetPostProcessingJsonDirectory().empty())
     {
       args.push_back("-pp");
       args.push_back(this->GetPostProcessingJsonDirectory());
     }
 
     spExec->Execute(this->GetPythonPath(), command, args);
   }
   try
   {
-    LabelSetImage::Pointer resultImage = LabelSetImage::New();
     Image::Pointer outputImage = IOUtil::Load<Image>(outputImagePath);
-    resultImage->InitializeByLabeledImage(outputImage);
-    resultImage->SetGeometry(inputAtTimeStep->GetGeometry());
+    previewImage->InitializeByLabeledImage(outputImage);
+    previewImage->SetGeometry(inputAtTimeStep->GetGeometry());
     m_InputBuffer = inputAtTimeStep;
-    m_OutputBuffer = resultImage;
-    return resultImage;
+    m_OutputBuffer = mitk::LabelSetImage::New();
+    m_OutputBuffer->InitializeByLabeledImage(outputImage);
+    m_OutputBuffer->SetGeometry(inputAtTimeStep->GetGeometry());
   }
   catch (const mitk::Exception &e)
   {
     /*
     Can't throw mitk exception to the caller. Refer: T28691
     */
     MITK_ERROR << e.GetDescription();
-    return nullptr;
+    return;
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitknnUnetTool.h b/Modules/Segmentation/Interactions/mitknnUnetTool.h
index 7e0fcffd7a..3923d8bd14 100644
--- a/Modules/Segmentation/Interactions/mitknnUnetTool.h
+++ b/Modules/Segmentation/Interactions/mitknnUnetTool.h
@@ -1,213 +1,214 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitknnUnetTool_h_Included
 #define mitknnUnetTool_h_Included
 
-#include "mitkAutoMLSegmentationWithPreviewTool.h"
+#include "mitkSegWithPreviewTool.h"
 #include "mitkCommon.h"
 #include "mitkToolManager.h"
 #include <MitkSegmentationExports.h>
 #include <mitkStandardFileLocations.h>
 #include <numeric>
 #include <utility>
 
 namespace us
 {
   class ModuleResource;
 }
 
 namespace mitk
 {
   /**
    * @brief nnUNet parameter request object holding all model parameters for input.
    * Also holds output temporary directory path.
    */
   struct ModelParams
   {
     std::string task;
     std::vector<std::string> folds;
     std::string model;
     std::string trainer;
     std::string planId;
     std::string outputDir;
     std::string inputName;
     std::string timeStamp;
 
     size_t generateHash() const
     {
       std::string toHash;
       std::string foldsConcatenated = std::accumulate(folds.begin(), folds.end(), std::string(""));
       toHash += this->task;
       toHash += this->model;
       toHash += this->inputName;
       toHash += foldsConcatenated;
       toHash += this->timeStamp;
       size_t hashVal = std::hash<std::string>{}(toHash);
       return hashVal;
     }
   };
 
   /**
     \brief nnUNet segmentation tool.
 
     \ingroup Interaction
     \ingroup ToolManagerEtAl
 
     \warning Only to be instantiated by mitk::ToolManager.
   */
-  class MITKSEGMENTATION_EXPORT nnUNetTool : public AutoMLSegmentationWithPreviewTool
+  class MITKSEGMENTATION_EXPORT nnUNetTool : public SegWithPreviewTool
   {
   public:
-    mitkClassMacro(nnUNetTool, AutoMLSegmentationWithPreviewTool);
+    mitkClassMacro(nnUNetTool, SegWithPreviewTool);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     const char **GetXPM() const override;
     const char *GetName() const override;
     us::ModuleResource GetIconResource() const override;
 
     void Activated() override;
 
     itkSetMacro(nnUNetDirectory, std::string);
     itkGetConstMacro(nnUNetDirectory, std::string);
 
     itkSetMacro(ModelDirectory, std::string);
     itkGetConstMacro(ModelDirectory, std::string);
 
     itkSetMacro(PythonPath, std::string);
     itkGetConstMacro(PythonPath, std::string);
 
     itkSetMacro(MitkTempDir, std::string);
     itkGetConstMacro(MitkTempDir, std::string);
 
     itkSetMacro(PostProcessingJsonDirectory, std::string);
     itkGetConstMacro(PostProcessingJsonDirectory, std::string);
 
     itkSetMacro(MixedPrecision, bool);
     itkGetConstMacro(MixedPrecision, bool);
     itkBooleanMacro(MixedPrecision);
 
     itkSetMacro(Mirror, bool);
     itkGetConstMacro(Mirror, bool);
     itkBooleanMacro(Mirror);
 
     itkSetMacro(MultiModal, bool);
     itkGetConstMacro(MultiModal, bool);
     itkBooleanMacro(MultiModal);
 
     itkSetMacro(NoPip, bool);
     itkGetConstMacro(NoPip, bool);
     itkBooleanMacro(NoPip);
 
     itkSetMacro(Ensemble, bool);
     itkGetConstMacro(Ensemble, bool);
     itkBooleanMacro(Ensemble);
 
     itkSetMacro(Predict, bool);
     itkGetConstMacro(Predict, bool);
     itkBooleanMacro(Predict);
 
     itkSetMacro(GpuId, unsigned int);
     itkGetConstMacro(GpuId, unsigned int);
 
     /**
      * @brief vector of ModelParams.
      * Size > 1 only for ensemble prediction.
      */
     std::vector<ModelParams> m_ParamQ;
 
     /**
      * @brief Holds paths to other input image modalities.
      *
      */
     std::vector<mitk::Image::ConstPointer> m_OtherModalPaths;
 
     mitk::Image::ConstPointer m_InputBuffer;
 
     /**
      * @brief Renders the output LabelSetImage.
      * To called in the main thread.
      */
     void RenderOutputBuffer();
 
     /**
      * @brief Get the Output Buffer object
      *
      * @return LabelSetImage::Pointer
      */
     LabelSetImage::Pointer GetOutputBuffer();
 
     /**
      * @brief Sets the outputBuffer to nullptr
      *
      */
     void ClearOutputBuffer();
 
     /**
      *  @brief Returns the DataStorage from the ToolManager
      */
     mitk::DataStorage *GetDataStorage();
 
     mitk::DataNode *GetRefNode();
 
     void SetOutputBuffer(LabelSetImage::Pointer);
 
   protected:
     /**
      * @brief Construct a new nnUNet Tool object and temp directory.
      *
      */
     nnUNetTool();
 
     /**
      * @brief Destroy the nnUNet Tool object and deletes the temp directory.
      *
      */
     ~nnUNetTool();
 
     /**
      * @brief Overriden method from the tool manager to execute the segmentation
      * Implementation:
      * 1. Saves the inputAtTimeStep in a temporary directory.
      * 2. Copies other modalities, renames and saves in the temporary directory, if required.
      * 3. Sets RESULTS_FOLDER and CUDA_VISIBLE_DEVICES variables in the environment.
      * 3. Iterates through the parameter queue (m_ParamQ) and executes "nnUNet_predict" command with the parameters
      * 4. Expects an output image to be saved in the temporary directory by the python proces. Loads it as
-     *    LabelSetImage and returns.
+     *    LabelSetImage and sets to previewImage.
      *
      * @param inputAtTimeStep
+     * @param oldSegAtTimeStep
+     * @param previewImage
      * @param timeStep
-     * @return LabelSetImage::Pointer
      */
-    LabelSetImage::Pointer ComputeMLPreview(const Image *inputAtTimeStep, TimeStepType timeStep) override;
+    void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep) override;
 
   private:
     std::string m_MitkTempDir;
     std::string m_nnUNetDirectory;
     std::string m_ModelDirectory;
     std::string m_PythonPath;
     std::string m_PostProcessingJsonDirectory;
     // bool m_UseGPU; kept for future
     // bool m_AllInGPU;
     bool m_MixedPrecision;
     bool m_Mirror;
     bool m_NoPip;
     bool m_MultiModal;
     bool m_Ensemble = false;
     bool m_Predict;
     LabelSetImage::Pointer m_OutputBuffer;
     unsigned int m_GpuId;
     const std::string m_TEMPLATE_FILENAME = "XXXXXX_000_0000.nii.gz";
   };
 } // namespace mitk
 #endif
diff --git a/Modules/Segmentation/SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.cpp b/Modules/Segmentation/SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.cpp
index 7f011e2a9e..c4a9b811b1 100644
--- a/Modules/Segmentation/SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.cpp
+++ b/Modules/Segmentation/SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.cpp
@@ -1,414 +1,414 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkMorphologicalOperations.h"
 #include <itkBinaryBallStructuringElement.h>
 #include <itkBinaryCrossStructuringElement.h>
 #include <itkBinaryDilateImageFilter.h>
 #include <itkBinaryErodeImageFilter.h>
 #include <itkBinaryFillholeImageFilter.h>
 #include <itkBinaryMorphologicalClosingImageFilter.h>
 #include <itkBinaryMorphologicalOpeningImageFilter.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkImageReadAccessor.h>
 #include <mitkImageTimeSelector.h>
 
 void mitk::MorphologicalOperations::Closing(mitk::Image::Pointer &image,
                                             int factor,
                                             mitk::MorphologicalOperations::StructuralElementType structuralElement)
 {
   MITK_INFO << "Start Closing...";
 
   auto timeSteps = static_cast<int>(image->GetTimeSteps());
 
   if (timeSteps > 1)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(image);
 
     for (int t = 0; t < timeSteps; ++t)
     {
       MITK_INFO << "  Processing time step " << t;
 
       timeSelector->SetTimeNr(t);
       timeSelector->Update();
 
       mitk::Image::Pointer img3D = timeSelector->GetOutput();
       img3D->DisconnectPipeline();
 
       AccessByItk_3(img3D, itkClosing, img3D, factor, structuralElement);
 
       mitk::ImageReadAccessor accessor(img3D);
       image->SetVolume(accessor.GetData(), t);
     }
   }
   else
   {
     AccessByItk_3(image, itkClosing, image, factor, structuralElement);
   }
 
   MITK_INFO << "Finished Closing";
 }
 
 void mitk::MorphologicalOperations::Erode(mitk::Image::Pointer &image,
                                           int factor,
                                           mitk::MorphologicalOperations::StructuralElementType structuralElement)
 {
   MITK_INFO << "Start Erode...";
 
   auto timeSteps = static_cast<int>(image->GetTimeSteps());
 
   if (timeSteps > 1)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(image);
 
     for (int t = 0; t < timeSteps; ++t)
     {
       MITK_INFO << "  Processing time step " << t;
 
       timeSelector->SetTimeNr(t);
       timeSelector->Update();
 
       mitk::Image::Pointer img3D = timeSelector->GetOutput();
       img3D->DisconnectPipeline();
 
       AccessByItk_3(img3D, itkErode, img3D, factor, structuralElement);
 
       mitk::ImageReadAccessor accessor(img3D);
       image->SetVolume(accessor.GetData(), t);
     }
   }
   else
   {
     AccessByItk_3(image, itkErode, image, factor, structuralElement);
   }
 
   MITK_INFO << "Finished Erode";
 }
 
 void mitk::MorphologicalOperations::Dilate(mitk::Image::Pointer &image,
                                            int factor,
                                            mitk::MorphologicalOperations::StructuralElementType structuralElement)
 {
   MITK_INFO << "Start Dilate...";
 
   auto timeSteps = static_cast<int>(image->GetTimeSteps());
 
   if (timeSteps > 1)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(image);
 
     for (int t = 0; t < timeSteps; ++t)
     {
       MITK_INFO << "  Processing time step " << t;
 
       timeSelector->SetTimeNr(t);
       timeSelector->Update();
 
       mitk::Image::Pointer img3D = timeSelector->GetOutput();
       img3D->DisconnectPipeline();
 
       AccessByItk_3(img3D, itkDilate, img3D, factor, structuralElement);
 
       mitk::ImageReadAccessor accessor(img3D);
       image->SetVolume(accessor.GetData(), t);
     }
   }
   else
   {
     AccessByItk_3(image, itkDilate, image, factor, structuralElement);
   }
 
   MITK_INFO << "Finished Dilate";
 }
 
 void mitk::MorphologicalOperations::Opening(mitk::Image::Pointer &image,
                                             int factor,
                                             mitk::MorphologicalOperations::StructuralElementType structuralElement)
 {
   MITK_INFO << "Start Opening...";
 
   auto timeSteps = static_cast<int>(image->GetTimeSteps());
 
   if (timeSteps > 1)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(image);
 
     for (int t = 0; t < timeSteps; ++t)
     {
       MITK_INFO << "  Processing time step " << t;
 
       timeSelector->SetTimeNr(t);
       timeSelector->Update();
 
       mitk::Image::Pointer img3D = timeSelector->GetOutput();
       img3D->DisconnectPipeline();
 
       AccessByItk_3(img3D, itkOpening, img3D, factor, structuralElement);
 
       mitk::ImageReadAccessor accessor(img3D);
       image->SetVolume(accessor.GetData(), t);
     }
   }
   else
   {
     AccessByItk_3(image, itkOpening, image, factor, structuralElement);
   }
 
   MITK_INFO << "Finished Opening";
 }
 
 void mitk::MorphologicalOperations::FillHoles(mitk::Image::Pointer &image)
 {
   MITK_INFO << "Start FillHole...";
 
   auto timeSteps = static_cast<int>(image->GetTimeSteps());
 
   if (timeSteps > 1)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(image);
 
     for (int t = 0; t < timeSteps; ++t)
     {
       MITK_INFO << "  Processing time step " << t;
 
       timeSelector->SetTimeNr(t);
       timeSelector->Update();
 
       mitk::Image::Pointer img3D = timeSelector->GetOutput();
       img3D->DisconnectPipeline();
 
       AccessByItk_1(img3D, itkFillHoles, img3D);
 
       mitk::ImageReadAccessor accessor(img3D);
       image->SetVolume(accessor.GetData(), t);
     }
   }
   else
   {
     AccessByItk_1(image, itkFillHoles, image);
   }
 
   MITK_INFO << "Finished FillHole";
 }
 
 template <typename TPixel, unsigned int VDimension>
 void mitk::MorphologicalOperations::itkClosing(
   itk::Image<TPixel, VDimension> *sourceImage,
   mitk::Image::Pointer &resultImage,
   int factor,
   mitk::MorphologicalOperations::StructuralElementType structuralElementFlags)
 {
   typedef itk::Image<TPixel, VDimension> ImageType;
   typedef itk::BinaryBallStructuringElement<TPixel, VDimension> BallType;
   typedef itk::BinaryCrossStructuringElement<TPixel, VDimension> CrossType;
   typedef typename itk::BinaryMorphologicalClosingImageFilter<ImageType, ImageType, BallType> BallClosingFilterType;
   typedef typename itk::BinaryMorphologicalClosingImageFilter<ImageType, ImageType, CrossType> CrossClosingFilterType;
 
-  if (structuralElementFlags & (Ball_Axial | Ball_Coronal | Ball_Sagital))
+  if (structuralElementFlags & (Ball_Axial | Ball_Coronal | Ball_Sagittal))
   {
     BallType ball = CreateStructuringElement<BallType>(structuralElementFlags, factor);
 
     typename BallClosingFilterType::Pointer closingFilter = BallClosingFilterType::New();
     closingFilter->SetKernel(ball);
     closingFilter->SetInput(sourceImage);
     closingFilter->SetForegroundValue(1);
     closingFilter->UpdateLargestPossibleRegion();
 
     mitk::CastToMitkImage(closingFilter->GetOutput(), resultImage);
   }
   else
   {
     CrossType cross = CreateStructuringElement<CrossType>(structuralElementFlags, factor);
 
     typename CrossClosingFilterType::Pointer closingFilter = CrossClosingFilterType::New();
     closingFilter->SetKernel(cross);
     closingFilter->SetInput(sourceImage);
     closingFilter->SetForegroundValue(1);
     closingFilter->UpdateLargestPossibleRegion();
 
     mitk::CastToMitkImage(closingFilter->GetOutput(), resultImage);
   }
 }
 
 template <typename TPixel, unsigned int VDimension>
 void mitk::MorphologicalOperations::itkErode(
   itk::Image<TPixel, VDimension> *sourceImage,
   mitk::Image::Pointer &resultImage,
   int factor,
   mitk::MorphologicalOperations::StructuralElementType structuralElementFlags)
 {
   typedef itk::Image<TPixel, VDimension> ImageType;
   typedef itk::BinaryBallStructuringElement<TPixel, VDimension> BallType;
   typedef itk::BinaryCrossStructuringElement<TPixel, VDimension> CrossType;
   typedef typename itk::BinaryErodeImageFilter<ImageType, ImageType, BallType> BallErodeFilterType;
   typedef typename itk::BinaryErodeImageFilter<ImageType, ImageType, CrossType> CrossErodeFilterType;
 
-  if (structuralElementFlags & (Ball_Axial | Ball_Coronal | Ball_Sagital))
+  if (structuralElementFlags & (Ball_Axial | Ball_Coronal | Ball_Sagittal))
   {
     BallType ball = CreateStructuringElement<BallType>(structuralElementFlags, factor);
 
     typename BallErodeFilterType::Pointer erodeFilter = BallErodeFilterType::New();
     erodeFilter->SetKernel(ball);
     erodeFilter->SetInput(sourceImage);
     erodeFilter->SetErodeValue(1);
     erodeFilter->UpdateLargestPossibleRegion();
 
     mitk::CastToMitkImage(erodeFilter->GetOutput(), resultImage);
   }
   else
   {
     CrossType cross = CreateStructuringElement<CrossType>(structuralElementFlags, factor);
 
     typename CrossErodeFilterType::Pointer erodeFilter = CrossErodeFilterType::New();
     erodeFilter->SetKernel(cross);
     erodeFilter->SetInput(sourceImage);
     erodeFilter->SetErodeValue(1);
     erodeFilter->UpdateLargestPossibleRegion();
 
     mitk::CastToMitkImage(erodeFilter->GetOutput(), resultImage);
   }
 }
 
 template <typename TPixel, unsigned int VDimension>
 void mitk::MorphologicalOperations::itkDilate(
   itk::Image<TPixel, VDimension> *sourceImage,
   mitk::Image::Pointer &resultImage,
   int factor,
   mitk::MorphologicalOperations::StructuralElementType structuralElementFlags)
 {
   typedef itk::Image<TPixel, VDimension> ImageType;
   typedef itk::BinaryBallStructuringElement<TPixel, VDimension> BallType;
   typedef itk::BinaryCrossStructuringElement<TPixel, VDimension> CrossType;
   typedef typename itk::BinaryDilateImageFilter<ImageType, ImageType, BallType> BallDilateFilterType;
   typedef typename itk::BinaryDilateImageFilter<ImageType, ImageType, CrossType> CrossDilateFilterType;
 
-  if (structuralElementFlags & (Ball_Axial | Ball_Coronal | Ball_Sagital))
+  if (structuralElementFlags & (Ball_Axial | Ball_Coronal | Ball_Sagittal))
   {
     BallType ball = CreateStructuringElement<BallType>(structuralElementFlags, factor);
 
     typename BallDilateFilterType::Pointer dilateFilter = BallDilateFilterType::New();
     dilateFilter->SetKernel(ball);
     dilateFilter->SetInput(sourceImage);
     dilateFilter->SetDilateValue(1);
     dilateFilter->UpdateLargestPossibleRegion();
 
     mitk::CastToMitkImage(dilateFilter->GetOutput(), resultImage);
   }
   else
   {
     CrossType cross = CreateStructuringElement<CrossType>(structuralElementFlags, factor);
 
     typename CrossDilateFilterType::Pointer dilateFilter = CrossDilateFilterType::New();
     dilateFilter->SetKernel(cross);
     dilateFilter->SetInput(sourceImage);
     dilateFilter->SetDilateValue(1);
     dilateFilter->UpdateLargestPossibleRegion();
 
     mitk::CastToMitkImage(dilateFilter->GetOutput(), resultImage);
   }
 }
 
 template <typename TPixel, unsigned int VDimension>
 void mitk::MorphologicalOperations::itkOpening(
   itk::Image<TPixel, VDimension> *sourceImage,
   mitk::Image::Pointer &resultImage,
   int factor,
   mitk::MorphologicalOperations::StructuralElementType structuralElementFlags)
 {
   typedef itk::Image<TPixel, VDimension> ImageType;
   typedef itk::BinaryBallStructuringElement<TPixel, VDimension> BallType;
   typedef itk::BinaryCrossStructuringElement<TPixel, VDimension> CrossType;
   typedef typename itk::BinaryMorphologicalOpeningImageFilter<ImageType, ImageType, BallType> BallOpeningFiltertype;
   typedef typename itk::BinaryMorphologicalOpeningImageFilter<ImageType, ImageType, CrossType> CrossOpeningFiltertype;
 
-  if (structuralElementFlags & (Ball_Axial | Ball_Coronal | Ball_Sagital))
+  if (structuralElementFlags & (Ball_Axial | Ball_Coronal | Ball_Sagittal))
   {
     BallType ball = CreateStructuringElement<BallType>(structuralElementFlags, factor);
 
     typename BallOpeningFiltertype::Pointer openingFilter = BallOpeningFiltertype::New();
     openingFilter->SetKernel(ball);
     openingFilter->SetInput(sourceImage);
     openingFilter->SetForegroundValue(1);
     openingFilter->SetBackgroundValue(0);
     openingFilter->UpdateLargestPossibleRegion();
 
     mitk::CastToMitkImage(openingFilter->GetOutput(), resultImage);
   }
   else
   {
     CrossType cross = CreateStructuringElement<CrossType>(structuralElementFlags, factor);
 
     typename CrossOpeningFiltertype::Pointer openingFilter = CrossOpeningFiltertype::New();
     openingFilter->SetKernel(cross);
     openingFilter->SetInput(sourceImage);
     openingFilter->SetForegroundValue(1);
     openingFilter->SetBackgroundValue(0);
     openingFilter->UpdateLargestPossibleRegion();
 
     mitk::CastToMitkImage(openingFilter->GetOutput(), resultImage);
   }
 }
 
 template <typename TPixel, unsigned int VDimension>
 void mitk::MorphologicalOperations::itkFillHoles(itk::Image<TPixel, VDimension> *sourceImage,
                                                  mitk::Image::Pointer &resultImage)
 {
   typedef itk::Image<TPixel, VDimension> ImageType;
   typedef typename itk::BinaryFillholeImageFilter<ImageType> FillHoleFilterType;
 
   typename FillHoleFilterType::Pointer fillHoleFilter = FillHoleFilterType::New();
   fillHoleFilter->SetInput(sourceImage);
   fillHoleFilter->SetForegroundValue(1);
   fillHoleFilter->UpdateLargestPossibleRegion();
 
   mitk::CastToMitkImage(fillHoleFilter->GetOutput(), resultImage);
 }
 
 template <class TStructuringElement>
 TStructuringElement  mitk::MorphologicalOperations::CreateStructuringElement(StructuralElementType structuralElementFlag, int factor)
 {
   TStructuringElement strElem;
   typename TStructuringElement::SizeType size;
   size.Fill(0);
   switch (structuralElementFlag)
   {
   case Ball_Axial:
   case Cross_Axial:
     size.SetElement(0, factor);
     size.SetElement(1, factor);
     break;
   case Ball_Coronal:
   case Cross_Coronal:
     size.SetElement(0, factor);
     size.SetElement(2, factor);
     break;
-  case Ball_Sagital:
-  case Cross_Sagital:
+  case Ball_Sagittal:
+  case Cross_Sagittal:
     size.SetElement(1, factor);
     size.SetElement(2, factor);
     break;
   case Ball:
   case Cross:
     size.Fill(factor);
     break;
   }
 
   strElem.SetRadius(size);
   strElem.CreateStructuringElement();
   return strElem;
 }
diff --git a/Modules/Segmentation/SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.h b/Modules/Segmentation/SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.h
index d5c7ebe3d6..6ebef0c35a 100644
--- a/Modules/Segmentation/SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.h
+++ b/Modules/Segmentation/SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.h
@@ -1,89 +1,89 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkMorphologicalOperations_h
 #define mitkMorphologicalOperations_h
 
 #include <MitkSegmentationExports.h>
 #include <mitkImage.h>
 
 namespace mitk
 {
   /** \brief Encapsulates several morphological operations that can be performed on segmentations.
     */
   class MITKSEGMENTATION_EXPORT MorphologicalOperations
   {
   public:
     enum StructuralElementType
     {
       Ball = 7,
       Ball_Axial = 1,
-      Ball_Sagital = 2,
+      Ball_Sagittal = 2,
       Ball_Coronal = 4,
 
       Cross = 56,
       Cross_Axial = 8,
-      Cross_Sagital = 16,
+      Cross_Sagittal = 16,
       Cross_Coronal = 32
 
     };
 
     ///@{
     /** \brief Perform morphological operation on 2D, 3D or 3D+t segmentation.
      */
     static void Closing(mitk::Image::Pointer &image, int factor, StructuralElementType structuralElement);
     static void Erode(mitk::Image::Pointer &image, int factor, StructuralElementType structuralElement);
     static void Dilate(mitk::Image::Pointer &image, int factor, StructuralElementType structuralElement);
     static void Opening(mitk::Image::Pointer &image, int factor, StructuralElementType structuralElement);
     static void FillHoles(mitk::Image::Pointer &image);
     ///@}
 
   private:
     MorphologicalOperations();
 
     template <class TStructuringElement>
     static TStructuringElement CreateStructuringElement(StructuralElementType structuralElementFlag, int factor);
 
     ///@{
     /** \brief Perform morphological operation by using corresponding ITK filter.
      */
     template <typename TPixel, unsigned int VDimension>
     static void itkClosing(itk::Image<TPixel, VDimension> *sourceImage,
                            mitk::Image::Pointer &resultImage,
                            int factor,
                            StructuralElementType structuralElement);
 
     template <typename TPixel, unsigned int VDimension>
     static void itkErode(itk::Image<TPixel, VDimension> *sourceImage,
                          mitk::Image::Pointer &resultImage,
                          int factor,
                          StructuralElementType structuralElement);
 
     template <typename TPixel, unsigned int VDimension>
     static void itkDilate(itk::Image<TPixel, VDimension> *sourceImage,
                           mitk::Image::Pointer &resultImage,
                           int factor,
                           StructuralElementType structuralElement);
 
     template <typename TPixel, unsigned int VDimension>
     static void itkOpening(itk::Image<TPixel, VDimension> *sourceImage,
                            mitk::Image::Pointer &resultImage,
                            int factor,
                            StructuralElementType structuralElement);
 
     template <typename TPixel, unsigned int VDimension>
     static void itkFillHoles(itk::Image<TPixel, VDimension> *sourceImage, mitk::Image::Pointer &resultImage);
     ///@}
   };
 }
 
 #endif
diff --git a/Modules/Segmentation/Testing/mitkSegmentationInterpolationTest.cpp b/Modules/Segmentation/Testing/mitkSegmentationInterpolationTest.cpp
index e16d8c6392..bf904c8303 100644
--- a/Modules/Segmentation/Testing/mitkSegmentationInterpolationTest.cpp
+++ b/Modules/Segmentation/Testing/mitkSegmentationInterpolationTest.cpp
@@ -1,204 +1,204 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // Testing
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 // other
 #include <mitkExtractSliceFilter.h>
 #include <mitkIOUtil.h>
 #include <mitkImage.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkImagePixelWriteAccessor.h>
 #include <mitkSegmentationInterpolationController.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkTool.h>
 #include <mitkVtkImageOverwrite.h>
 
 class mitkSegmentationInterpolationTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkSegmentationInterpolationTestSuite);
   MITK_TEST(Equal_Axial_TestInterpolationAndReferenceInterpolation_ReturnsTrue);
-  MITK_TEST(Equal_Frontal_TestInterpolationAndReferenceInterpolation_ReturnsTrue);
+  MITK_TEST(Equal_Coronal_TestInterpolationAndReferenceInterpolation_ReturnsTrue);
   MITK_TEST(Equal_Sagittal_TestInterpolationAndReferenceInterpolation_ReturnsTrue);
   CPPUNIT_TEST_SUITE_END();
 
 private:
   // The tests all do the same, only in different directions
   void testRoutine(mitk::SliceNavigationController::ViewDirection viewDirection)
   {
     int dim;
     switch (viewDirection)
     {
       case (mitk::SliceNavigationController::Axial):
         dim = 2;
         break;
-      case (mitk::SliceNavigationController::Frontal):
+      case (mitk::SliceNavigationController::Coronal):
         dim = 1;
         break;
       case (mitk::SliceNavigationController::Sagittal):
         dim = 0;
         break;
       default: // mitk::SliceNavigationController::Original
         dim = -1;
         break;
     }
 
     /* Fill segmentation
      *
      * 1st slice: 3x3 square segmentation
      * 2nd slice: empty
      * 3rd slice: 1x1 square segmentation in corner
      * -> 2nd slice should become 2x2 square in corner
      *
      * put accessor in scope
      */
 
     itk::Index<3> currentPoint;
     {
       mitk::ImagePixelWriteAccessor<mitk::Tool::DefaultSegmentationDataType, 3> writeAccessor(m_SegmentationImage);
 
       // Fill 3x3 slice
       currentPoint[dim] = m_CenterPoint[dim] - 1;
       for (int i = -1; i <= 1; ++i)
       {
         for (int j = -1; j <= 1; ++j)
         {
           currentPoint[(dim + 1) % 3] = m_CenterPoint[(dim + 1) % 3] + i;
           currentPoint[(dim + 2) % 3] = m_CenterPoint[(dim + 2) % 3] + j;
           writeAccessor.SetPixelByIndexSafe(currentPoint, 1);
         }
       }
       // Now i=j=1, set point two slices up
       currentPoint[dim] = m_CenterPoint[dim] + 1;
       writeAccessor.SetPixelByIndexSafe(currentPoint, 1);
     }
 
     //        mitk::IOUtil::Save(m_SegmentationImage, "SOME PATH");
 
     m_InterpolationController->SetSegmentationVolume(m_SegmentationImage);
     m_InterpolationController->SetReferenceVolume(m_ReferenceImage);
 
     // This could be easier...
     mitk::SliceNavigationController::Pointer navigationController = mitk::SliceNavigationController::New();
     navigationController->SetInputWorldTimeGeometry(m_SegmentationImage->GetTimeGeometry());
     navigationController->Update(viewDirection);
     mitk::Point3D pointMM;
     m_SegmentationImage->GetTimeGeometry()->GetGeometryForTimeStep(0)->IndexToWorld(m_CenterPoint, pointMM);
     navigationController->SelectSliceByPoint(pointMM);
     auto plane = navigationController->GetCurrentPlaneGeometry();
     mitk::Image::Pointer interpolationResult =
       m_InterpolationController->Interpolate(dim, m_CenterPoint[dim], plane, 0);
 
     //        mitk::IOUtil::Save(interpolationResult, "SOME PATH");
 
     // Write result into segmentation image
     vtkSmartPointer<mitkVtkImageOverwrite> reslicer = vtkSmartPointer<mitkVtkImageOverwrite>::New();
     reslicer->SetInputSlice(
       interpolationResult->GetSliceData()->GetVtkImageAccessor(interpolationResult)->GetVtkImageData());
     reslicer->SetOverwriteMode(true);
     reslicer->Modified();
     mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslicer);
     extractor->SetInput(m_SegmentationImage);
     extractor->SetTimeStep(0);
     extractor->SetWorldGeometry(plane);
     extractor->SetVtkOutputRequest(true);
     extractor->SetResliceTransformByGeometry(m_SegmentationImage->GetTimeGeometry()->GetGeometryForTimeStep(0));
     extractor->Modified();
     extractor->Update();
 
     //        mitk::IOUtil::Save(m_SegmentationImage, "SOME PATH");
 
     // Check a 4x4 square, the center of which needs to be filled
     mitk::ImagePixelReadAccessor<mitk::Tool::DefaultSegmentationDataType, 3> readAccess(m_SegmentationImage);
     currentPoint = m_CenterPoint;
 
     for (int i = -1; i <= 2; ++i)
     {
       for (int j = -1; j <= 2; ++j)
       {
         currentPoint[(dim + 1) % 3] = m_CenterPoint[(dim + 1) % 3] + i;
         currentPoint[(dim + 2) % 3] = m_CenterPoint[(dim + 2) % 3] + j;
 
         if (i == -1 || i == 2 || j == -1 || j == 2)
         {
           CPPUNIT_ASSERT_MESSAGE("Have false positive segmentation.",
                                  readAccess.GetPixelByIndexSafe(currentPoint) == 0);
         }
         else
         {
           CPPUNIT_ASSERT_MESSAGE("Have false negative segmentation.",
                                  readAccess.GetPixelByIndexSafe(currentPoint) == 1);
         }
       }
     }
   }
 
   mitk::Image::Pointer m_ReferenceImage;
   mitk::Image::Pointer m_SegmentationImage;
   itk::Index<3> m_CenterPoint;
   mitk::SegmentationInterpolationController::Pointer m_InterpolationController;
 
 public:
   void setUp() override
   {
     m_ReferenceImage = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Pic3D.nrrd"));
     CPPUNIT_ASSERT_MESSAGE("Failed to load image for test: [Pic3D.nrrd]", m_ReferenceImage.IsNotNull());
 
     m_InterpolationController = mitk::SegmentationInterpolationController::GetInstance();
 
     // Create empty segmentation
     // Surely there must be a better way to get an image with all zeros?
     m_SegmentationImage = mitk::Image::New();
     const mitk::PixelType pixelType(mitk::MakeScalarPixelType<mitk::Tool::DefaultSegmentationDataType>());
     m_SegmentationImage->Initialize(pixelType, m_ReferenceImage->GetDimension(), m_ReferenceImage->GetDimensions());
     m_SegmentationImage->SetClonedTimeGeometry(m_ReferenceImage->GetTimeGeometry());
     unsigned int size = sizeof(mitk::Tool::DefaultSegmentationDataType);
     for (unsigned int dim = 0; dim < m_SegmentationImage->GetDimension(); ++dim)
     {
       size *= m_SegmentationImage->GetDimension(dim);
     }
     mitk::ImageWriteAccessor imageAccessor(m_SegmentationImage);
     memset(imageAccessor.GetData(), 0, size);
 
     // Work in the center of the image (Pic3D)
     m_CenterPoint = {{127, 127, 25}};
   }
 
   void tearDown() override
   {
     m_ReferenceImage = nullptr;
     m_SegmentationImage = nullptr;
     m_CenterPoint = {{0, 0, 0}};
   }
 
   void Equal_Axial_TestInterpolationAndReferenceInterpolation_ReturnsTrue()
   {
     mitk::SliceNavigationController::ViewDirection viewDirection = mitk::SliceNavigationController::Axial;
     testRoutine(viewDirection);
   }
 
-  void Equal_Frontal_TestInterpolationAndReferenceInterpolation_ReturnsTrue() // Coronal
+  void Equal_Coronal_TestInterpolationAndReferenceInterpolation_ReturnsTrue() // Coronal
   {
-    mitk::SliceNavigationController::ViewDirection viewDirection = mitk::SliceNavigationController::Frontal;
+    mitk::SliceNavigationController::ViewDirection viewDirection = mitk::SliceNavigationController::Coronal;
     testRoutine(viewDirection);
   }
 
   void Equal_Sagittal_TestInterpolationAndReferenceInterpolation_ReturnsTrue()
   {
     mitk::SliceNavigationController::ViewDirection viewDirection = mitk::SliceNavigationController::Sagittal;
     testRoutine(viewDirection);
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkSegmentationInterpolation)
diff --git a/Modules/Segmentation/files.cmake b/Modules/Segmentation/files.cmake
index e8f1ecffb7..d931118bc0 100644
--- a/Modules/Segmentation/files.cmake
+++ b/Modules/Segmentation/files.cmake
@@ -1,110 +1,107 @@
 set(CPP_FILES
   Algorithms/mitkCalculateSegmentationVolume.cpp
   Algorithms/mitkContourModelSetToImageFilter.cpp
   Algorithms/mitkContourSetToPointSetFilter.cpp
   Algorithms/mitkContourUtils.cpp
   Algorithms/mitkCorrectorAlgorithm.cpp
   Algorithms/mitkDiffImageApplier.cpp
   Algorithms/mitkDiffSliceOperation.cpp
   Algorithms/mitkDiffSliceOperationApplier.cpp
   Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
   Algorithms/mitkImageLiveWireContourModelFilter.cpp
   Algorithms/mitkImageToContourFilter.cpp
   #Algorithms/mitkImageToContourModelFilter.cpp
   Algorithms/mitkImageToLiveWireContourFilter.cpp
   Algorithms/mitkManualSegmentationToSurfaceFilter.cpp
   Algorithms/mitkOtsuSegmentationFilter.cpp
   Algorithms/mitkSegmentationObjectFactory.cpp
   Algorithms/mitkShapeBasedInterpolationAlgorithm.cpp
   Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
   Algorithms/mitkShowSegmentationAsSurface.cpp
   Algorithms/mitkVtkImageOverwrite.cpp
   Controllers/mitkSegmentationInterpolationController.cpp
   Controllers/mitkToolManager.cpp
   Controllers/mitkSegmentationModuleActivator.cpp
   Controllers/mitkToolManagerProvider.cpp
   DataManagement/mitkContour.cpp
   DataManagement/mitkContourSet.cpp
   DataManagement/mitkExtrudedContour.cpp
-  Interactions/mitkAdaptiveRegionGrowingTool.cpp
   Interactions/mitkAddContourTool.cpp
   Interactions/mitkAutoCropTool.cpp
-  Interactions/mitkAutoSegmentationTool.cpp
-  Interactions/mitkAutoSegmentationWithPreviewTool.cpp
-  Interactions/mitkAutoMLSegmentationWithPreviewTool.cpp
+  Interactions/mitkSegWithPreviewTool.cpp
   Interactions/mitkBinaryThresholdBaseTool.cpp
   Interactions/mitkBinaryThresholdTool.cpp
   Interactions/mitkBinaryThresholdULTool.cpp
   Interactions/mitkCalculateGrayValueStatisticsTool.cpp
   Interactions/mitkCalculateVolumetryTool.cpp
   Interactions/mitkContourModelInteractor.cpp
   Interactions/mitkContourModelLiveWireInteractor.cpp
   Interactions/mitkLiveWireTool2D.cpp
   Interactions/mitkContourTool.cpp
   Interactions/mitkCreateSurfaceTool.cpp
   Interactions/mitkDrawPaintbrushTool.cpp
   Interactions/mitkErasePaintbrushTool.cpp
   Interactions/mitkEraseRegionTool.cpp
   Interactions/mitkFeedbackContourTool.cpp
   Interactions/mitkFillRegionTool.cpp
   Interactions/mitkOtsuTool3D.cpp
   Interactions/mitkPaintbrushTool.cpp
   Interactions/mitkPixelManipulationTool.cpp
   Interactions/mitkRegionGrowingTool.cpp
   Interactions/mitkSegmentationsProcessingTool.cpp
   Interactions/mitkSetRegionTool.cpp
   Interactions/mitkSegTool2D.cpp
   Interactions/mitkSubtractContourTool.cpp
   Interactions/mitkTool.cpp
   Interactions/mitkToolCommand.cpp
   Interactions/mitkPickingTool.cpp
   Interactions/mitknnUnetTool.cpp
   Interactions/mitkSegmentationInteractor.cpp #SO
   Interactions/mitkProcessExecutor.cpp
   Rendering/mitkContourMapper2D.cpp
   Rendering/mitkContourSetMapper2D.cpp
   Rendering/mitkContourSetVtkMapper3D.cpp
   Rendering/mitkContourVtkMapper3D.cpp
   SegmentationUtilities/BooleanOperations/mitkBooleanOperation.cpp
   SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.cpp
 #Added from ML
   Controllers/mitkSliceBasedInterpolationController.cpp
   Algorithms/mitkSurfaceStampImageFilter.cpp
 )
 
 set(RESOURCE_FILES
   Add_48x48.png
   Add_Cursor_32x32.png
   AI_48x48.png
   AI_Cursor_32x32.png
   Erase_48x48.png
   Erase_Cursor_32x32.png
   Fill_48x48.png
   Fill_Cursor_32x32.png
   LiveWire_48x48.png
   LiveWire_Cursor_32x32.png
   Otsu_48x48.png
   Paint_48x48.png
   Paint_Cursor_32x32.png
   Pick_48x48.png
   RegionGrowing_48x48.png
   RegionGrowing_Cursor_32x32.png
   Subtract_48x48.png
   Subtract_Cursor_32x32.png
   Threshold_48x48.png
   TwoThresholds_48x48.png
   Wipe_48x48.png
   Wipe_Cursor_32x32.png
 
   Interactions/dummy.xml
   Interactions/LiveWireTool.xml
   Interactions/PickingTool.xml
   Interactions/PressMoveRelease.xml
   Interactions/PressMoveReleaseAndPointSetting.xml
   Interactions/PressMoveReleaseWithCTRLInversion.xml
   Interactions/PressMoveReleaseWithCTRLInversionAllMouseMoves.xml
   Interactions/SegmentationToolsConfig.xml
 
   Interactions/ContourModelModificationConfig.xml
   Interactions/ContourModelModificationInteractor.xml
 )
diff --git a/Modules/SegmentationUI/CMakeLists.txt b/Modules/SegmentationUI/CMakeLists.txt
index daf52bda9c..be064b6867 100644
--- a/Modules/SegmentationUI/CMakeLists.txt
+++ b/Modules/SegmentationUI/CMakeLists.txt
@@ -1,5 +1,5 @@
 MITK_CREATE_MODULE (
 INCLUDE_DIRS Qmitk
 DEPENDS MitkSegmentation MitkQtWidgetsExt
-PACKAGE_DEPENDS CTK|CTKWidgets
+PACKAGE_DEPENDS PRIVATE CTK|CTKWidgets nlohmann_json
 )
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
deleted file mode 100644
index 2b6853bb74..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
+++ /dev/null
@@ -1,1006 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-#include "QmitkAdaptiveRegionGrowingToolGUI.h"
-
-#include <qmessagebox.h>
-
-#include "mitkITKImageImport.h"
-#include "mitkImageAccessByItk.h"
-#include "mitkImageTimeSelector.h"
-#include "mitkNodePredicateDataType.h"
-#include "mitkProperties.h"
-#include "mitkTransferFunctionProperty.h"
-
-#include "mitkImageStatisticsHolder.h"
-
-#include "itkMaskImageFilter.h"
-#include "itkNumericTraits.h"
-#include <itkBinaryThresholdImageFilter.h>
-#include <itkConnectedAdaptiveThresholdImageFilter.h>
-#include <itkImageIterator.h>
-#include <itkMinimumMaximumImageCalculator.h>
-
-#include "QmitkConfirmSegmentationDialog.h"
-#include "itkOrImageFilter.h"
-#include "mitkImageCast.h"
-
-#include "mitkImagePixelReadAccessor.h"
-#include "mitkPixelTypeMultiplex.h"
-
-#include "mitkImageCast.h"
-
-MITK_TOOL_GUI_MACRO(, QmitkAdaptiveRegionGrowingToolGUI, "")
-
-QmitkAdaptiveRegionGrowingToolGUI::QmitkAdaptiveRegionGrowingToolGUI(QWidget *parent)
-  : QmitkToolGUI(),
-    m_DataStorage(nullptr),
-    m_UseVolumeRendering(false),
-    m_UpdateSuggestedThreshold(true),
-    m_SuggestedThValue(0.0)
-{
-  this->setParent(parent);
-
-  m_Controls.setupUi(this);
-
-  m_Controls.m_ThresholdSlider->setDecimals(1);
-  m_Controls.m_ThresholdSlider->setSpinBoxAlignment(Qt::AlignVCenter);
-
-  m_Controls.m_PreviewSlider->setEnabled(false);
-  m_Controls.m_PreviewSlider->setSingleStep(0.5);
-  // Not yet available
-  // m_Controls.m_PreviewSlider->InvertedAppearance(true);
-
-  //3D preview doesn't work: T24430. Postponed until reimplementation of segmentation
-  m_Controls.m_cbVolumeRendering->setVisible(false);
-
-  this->CreateConnections();
-  this->SetDataNodeNames("labeledRGSegmentation", "RGResult", "RGFeedbackSurface", "maskedSegmentation");
-
-  connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
-}
-
-QmitkAdaptiveRegionGrowingToolGUI::~QmitkAdaptiveRegionGrowingToolGUI()
-{
-  // Removing the observer of the PointSet node
-  if (m_RegionGrow3DTool->GetPointSetNode().IsNotNull())
-  {
-    m_RegionGrow3DTool->GetPointSetNode()->GetData()->RemoveObserver(m_PointSetAddObserverTag);
-    m_RegionGrow3DTool->GetPointSetNode()->GetData()->RemoveObserver(m_PointSetMoveObserverTag);
-  }
-  this->RemoveHelperNodes();
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::OnNewToolAssociated(mitk::Tool *tool)
-{
-  m_RegionGrow3DTool = dynamic_cast<mitk::AdaptiveRegionGrowingTool *>(tool);
-  if (m_RegionGrow3DTool.IsNotNull())
-  {
-    SetInputImageNode(this->m_RegionGrow3DTool->GetReferenceData());
-    this->m_DataStorage = this->m_RegionGrow3DTool->GetDataStorage();
-    this->EnableControls(true);
-
-    // Watch for point added or modified
-    itk::SimpleMemberCommand<QmitkAdaptiveRegionGrowingToolGUI>::Pointer pointAddedCommand =
-      itk::SimpleMemberCommand<QmitkAdaptiveRegionGrowingToolGUI>::New();
-    pointAddedCommand->SetCallbackFunction(this, &QmitkAdaptiveRegionGrowingToolGUI::OnPointAdded);
-    m_PointSetAddObserverTag =
-      m_RegionGrow3DTool->GetPointSetNode()->GetData()->AddObserver(mitk::PointSetAddEvent(), pointAddedCommand);
-    m_PointSetMoveObserverTag =
-      m_RegionGrow3DTool->GetPointSetNode()->GetData()->AddObserver(mitk::PointSetMoveEvent(), pointAddedCommand);
-  }
-  else
-  {
-    this->EnableControls(false);
-  }
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::RemoveHelperNodes()
-{
-  mitk::DataNode::Pointer imageNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
-  if (imageNode.IsNotNull())
-  {
-    m_DataStorage->Remove(imageNode);
-  }
-
-  mitk::DataNode::Pointer maskedSegmentationNode = m_DataStorage->GetNamedNode(m_NAMEFORMASKEDSEGMENTATION);
-  if (maskedSegmentationNode.IsNotNull())
-  {
-    m_DataStorage->Remove(maskedSegmentationNode);
-  }
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::CreateConnections()
-{
-  // Connecting GUI components
-  connect((QObject *)(m_Controls.m_pbRunSegmentation), SIGNAL(clicked()), this, SLOT(RunSegmentation()));
-  connect(m_Controls.m_PreviewSlider, SIGNAL(valueChanged(double)), this, SLOT(ChangeLevelWindow(double)));
-  connect((QObject *)(m_Controls.m_pbConfirmSegementation), SIGNAL(clicked()), this, SLOT(ConfirmSegmentation()));
-  connect(
-    m_Controls.m_ThresholdSlider, SIGNAL(maximumValueChanged(double)), this, SLOT(SetUpperThresholdValue(double)));
-  connect(
-    m_Controls.m_ThresholdSlider, SIGNAL(minimumValueChanged(double)), this, SLOT(SetLowerThresholdValue(double)));
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::SetDataNodeNames(std::string labledSegmentation,
-                                                         std::string binaryImage,
-                                                         std::string surface,
-                                                         std::string maskedSegmentation)
-{
-  m_NAMEFORLABLEDSEGMENTATIONIMAGE = labledSegmentation;
-  m_NAMEFORBINARYIMAGE = binaryImage;
-  m_NAMEFORSURFACE = surface;
-  m_NAMEFORMASKEDSEGMENTATION = maskedSegmentation;
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::SetDataStorage(mitk::DataStorage *dataStorage)
-{
-  m_DataStorage = dataStorage;
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::SetInputImageNode(mitk::DataNode *node)
-{
-  m_InputImageNode = node;
-  mitk::Image *inputImage = dynamic_cast<mitk::Image *>(m_InputImageNode->GetData());
-  if (inputImage)
-  {
-    mitk::ScalarType max = inputImage->GetStatistics()->GetScalarValueMax();
-    mitk::ScalarType min = inputImage->GetStatistics()->GetScalarValueMin();
-    m_Controls.m_ThresholdSlider->setMaximum(max);
-    m_Controls.m_ThresholdSlider->setMinimum(min);
-    // Just for initialization
-    m_Controls.m_ThresholdSlider->setMaximumValue(max);
-    m_Controls.m_ThresholdSlider->setMinimumValue(min);
-  }
-}
-
-template <typename TPixel>
-static void AccessPixel(mitk::PixelType /*ptype*/, mitk::Image* im, mitk::Point3D p, int& val)
-{
-  mitk::ImagePixelReadAccessor<TPixel, 3> access(im);
-  val = access.GetPixelByWorldCoordinates(p);
-}
-
-/**Overloaded const verison*/
-template <typename TPixel>
-static void AccessPixel(mitk::PixelType /*ptype*/, const mitk::Image* im, mitk::Point3D p, int& val)
-{
-  mitk::ImagePixelReadAccessor<TPixel, 3> access(im);
-  val = access.GetPixelByWorldCoordinates(p);
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::OnPointAdded()
-{
-  if (m_RegionGrow3DTool.IsNull())
-    return;
-
-  mitk::DataNode *node = m_RegionGrow3DTool->GetPointSetNode();
-
-  if (node != nullptr)
-  {
-    mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet *>(node->GetData());
-
-    if (pointSet.IsNull())
-    {
-      QMessageBox::critical(nullptr, "QmitkAdaptiveRegionGrowingToolGUI", "PointSetNode does not contain a pointset");
-      return;
-    }
-
-    m_Controls.m_lblSetSeedpoint->setText("");
-
-    const mitk::Image *image = dynamic_cast<mitk::Image *>(m_InputImageNode->GetData());
-    const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
-
-    auto image3D = GetImageByTimePoint(image, timePoint);
-
-    if (nullptr == image3D)
-    {
-      MITK_WARN << "Cannot run segementation. Currently selected timepoint is not in the time bounds of the selected "
-                   "reference image. Time point: "
-                << timePoint;
-      return;
-    }
-
-    if (!pointSet->GetTimeGeometry()->IsValidTimePoint(timePoint))
-      return;
-
-    mitk::Point3D seedPoint =
-      pointSet
-        ->GetPointSet(static_cast<int>(pointSet->GetTimeGeometry()->TimePointToTimeStep(timePoint)))
-        ->GetPoints()
-        ->ElementAt(0);
-
-    if (image3D->GetGeometry()->IsInside(seedPoint))
-      mitkPixelTypeMultiplex3(
-        AccessPixel, image3D->GetChannelDescriptor().GetPixelType(), image3D, seedPoint, m_SeedpointValue) else return;
-
-    /* In this case the seedpoint is placed e.g. in the lung or bronchialtree
-     * The lowerFactor sets the windowsize depending on the regiongrowing direction
-     */
-    m_CurrentRGDirectionIsUpwards = true;
-    if (m_SeedpointValue < -500)
-    {
-      m_CurrentRGDirectionIsUpwards = false;
-    }
-
-    // Initializing the region by the area around the seedpoint
-    m_SeedPointValueMean = 0;
-
-    itk::Index<3> currentIndex, runningIndex;
-    mitk::ScalarType pixelValues[125];
-    unsigned int pos(0);
-
-    image3D->GetGeometry(0)->WorldToIndex(seedPoint, currentIndex);
-    runningIndex = currentIndex;
-
-    for (int i = runningIndex[0] - 2; i <= runningIndex[0] + 2; i++)
-    {
-      for (int j = runningIndex[1] - 2; j <= runningIndex[1] + 2; j++)
-      {
-        for (int k = runningIndex[2] - 2; k <= runningIndex[2] + 2; k++)
-        {
-          currentIndex[0] = i;
-          currentIndex[1] = j;
-          currentIndex[2] = k;
-
-          if (image3D->GetGeometry()->IsIndexInside(currentIndex))
-          {
-            int component = 0;
-            m_InputImageNode->GetIntProperty("Image.Displayed Component", component);
-            mitkPixelTypeMultiplex4(mitk::FastSinglePixelAccess,
-                                    image3D->GetChannelDescriptor().GetPixelType(),
-                                    image3D,
-                                    nullptr,
-                                    currentIndex,
-                                    pixelValues[pos]);
-
-            pos++;
-          }
-          else
-          {
-            pixelValues[pos] = std::numeric_limits<long>::min();
-            pos++;
-          }
-        }
-      }
-    }
-
-    // Now calculation mean of the pixelValues
-    // Now calculation mean of the pixelValues
-    unsigned int numberOfValues(0);
-    for (auto &pixelValue : pixelValues)
-    {
-      if (pixelValue > std::numeric_limits<long>::min())
-      {
-        m_SeedPointValueMean += pixelValue;
-        numberOfValues++;
-      }
-    }
-    m_SeedPointValueMean = m_SeedPointValueMean / numberOfValues;
-
-    mitk::ScalarType var = 0;
-    if (numberOfValues > 1)
-    {
-      for (auto &pixelValue : pixelValues)
-      {
-        if (pixelValue > std::numeric_limits<mitk::ScalarType>::min())
-        {
-          var += (pixelValue - m_SeedPointValueMean) * (pixelValue - m_SeedPointValueMean);
-        }
-      }
-      var /= numberOfValues - 1;
-    }
-    mitk::ScalarType stdDev = sqrt(var);
-
-    /*
-     * Here the upper- and lower threshold is calculated:
-     * The windowSize is 20% of the maximum range of the intensity values existing in the current image
-     * If the RG direction is upwards the lower TH is meanSeedValue-0.15*windowSize and upper TH is
-     * meanSeedValue+0.85*windowsSize
-     * if the RG direction is downwards the lower TH is meanSeedValue-0.85*windowSize and upper TH is
-     * meanSeedValue+0.15*windowsSize
-     */
-    const auto timeStepOfImage = image->GetTimeGeometry()->TimePointToTimeStep(timePoint);
-    mitk::ScalarType min = image->GetStatistics()->GetScalarValueMin(timeStepOfImage);
-    mitk::ScalarType max = image->GetStatistics()->GetScalarValueMax(timeStepOfImage);
-
-    mitk::ScalarType windowSize = max - min;
-
-    windowSize = 0.15 * windowSize;
-
-    if (m_CurrentRGDirectionIsUpwards)
-    {
-      m_LOWERTHRESHOLD = m_SeedPointValueMean - stdDev;
-      m_UPPERTHRESHOLD = m_SeedpointValue + windowSize;
-      if (m_UPPERTHRESHOLD > max)
-        m_UPPERTHRESHOLD = max;
-      m_Controls.m_ThresholdSlider->setMaximumValue(m_UPPERTHRESHOLD);
-      m_Controls.m_ThresholdSlider->setMinimumValue(m_LOWERTHRESHOLD);
-    }
-    else
-    {
-      m_UPPERTHRESHOLD = m_SeedPointValueMean;
-      if (m_SeedpointValue > m_SeedPointValueMean)
-        m_UPPERTHRESHOLD = m_SeedpointValue;
-      m_LOWERTHRESHOLD = m_SeedpointValue - windowSize;
-      if (m_LOWERTHRESHOLD < min)
-        m_LOWERTHRESHOLD = min;
-      m_Controls.m_ThresholdSlider->setMinimumValue(m_LOWERTHRESHOLD);
-      m_Controls.m_ThresholdSlider->setMaximumValue(m_UPPERTHRESHOLD);
-    }
-  }
-}
-
-mitk::Image::ConstPointer QmitkAdaptiveRegionGrowingToolGUI::GetImageByTimePoint(const mitk::Image *image,
-                                                                                   mitk::TimePointType timePoint) const
-{
-  if (nullptr == image)
-    return image;
-
-  if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
-    return nullptr;
-
-  if (image->GetDimension() != 4)
-    return image;
-
-  auto imageTimeSelector = mitk::ImageTimeSelector::New();
-
-  imageTimeSelector->SetInput(image);
-  imageTimeSelector->SetTimeNr(static_cast<int>(image->GetTimeGeometry()->TimePointToTimeStep(timePoint)));
-
-  imageTimeSelector->UpdateLargestPossibleRegion();
-
-  return imageTimeSelector->GetOutput();
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::RunSegmentation()
-{
-  if (m_InputImageNode.IsNull())
-  {
-    QMessageBox::information(nullptr, "Adaptive Region Growing functionality", "Please specify the image in Datamanager!");
-    return;
-  }
-
-  mitk::DataNode::Pointer node = m_RegionGrow3DTool->GetPointSetNode();
-
-  if (node.IsNull())
-  {
-    QMessageBox::information(nullptr, "Adaptive Region Growing functionality", "Please insert a seed point inside the "
-                                                                            "image.\n\nFirst press the \"Define Seed "
-                                                                            "Point\" button,\nthen click left mouse "
-                                                                            "button inside the image.");
-    return;
-  }
-
-  // safety if no pointSet or pointSet empty
-  mitk::PointSet::Pointer seedPointSet = dynamic_cast<mitk::PointSet *>(node->GetData());
-  if (seedPointSet.IsNull())
-  {
-    m_Controls.m_pbRunSegmentation->setEnabled(true);
-    QMessageBox::information(
-      nullptr, "Adaptive Region Growing functionality", "The seed point is empty! Please choose a new seed point.");
-    return;
-  }
-
-  mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image *>(m_InputImageNode->GetData());
-
-  if (orgImage.IsNotNull())
-  {
-    const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
-
-    if (!seedPointSet->GetTimeGeometry()->IsValidTimePoint(timePoint))
-      mitkThrow() << "Point set is not defined for specified time point. Time point: " << timePoint;
-
-    int timeStep = static_cast<int>(seedPointSet->GetTimeGeometry()->TimePointToTimeStep(timePoint));
-
-    if (!(seedPointSet->GetSize(timeStep)))
-    {
-      m_Controls.m_pbRunSegmentation->setEnabled(true);
-      QMessageBox::information(
-        nullptr, "Adaptive Region Growing functionality", "The seed point is empty! Please choose a new seed point.");
-      return;
-    }
-
-    QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
-
-    mitk::PointSet::PointType seedPoint = seedPointSet->GetPointSet(timeStep)->GetPoints()->Begin().Value();
-
-    auto image3D = GetImageByTimePoint(orgImage, timePoint);
-
-    if (image3D.IsNotNull())
-    {
-      // QApplication::setOverrideCursor(QCursor(Qt::WaitCursor)); //set the cursor to waiting
-      AccessByItk_2(image3D, StartRegionGrowing, image3D->GetGeometry(), seedPoint);
-      // QApplication::restoreOverrideCursor();//reset cursor
-    }
-    else
-    {
-      QApplication::restoreOverrideCursor(); // reset cursor
-      QMessageBox::information(
-        nullptr, "Adaptive Region Growing functionality", "Only images of dimension 3 or 4 can be processed!");
-      return;
-    }
-  }
-  EnableControls(true); // Segmentation ran successfully, so enable all controls.
-  node->SetVisibility(true);
-  QApplication::restoreOverrideCursor(); // reset cursor
-}
-
-template <typename TPixel, unsigned int VImageDimension>
-void QmitkAdaptiveRegionGrowingToolGUI::StartRegionGrowing(const itk::Image<TPixel, VImageDimension> *itkImage,
-                                                           const mitk::BaseGeometry *imageGeometry,
-                                                           const mitk::PointSet::PointType seedPoint)
-{
-  typedef itk::Image<TPixel, VImageDimension> InputImageType;
-  typedef typename InputImageType::IndexType IndexType;
-  typedef itk::ConnectedAdaptiveThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
-  typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
-  typedef itk::BinaryThresholdImageFilter<InputImageType, InputImageType> ThresholdFilterType;
-  typedef itk::MaskImageFilter<InputImageType, InputImageType, InputImageType> MaskImageFilterType;
-
-  if (!imageGeometry->IsInside(seedPoint))
-  {
-    QApplication::restoreOverrideCursor(); // reset cursor to be able to click ok with the regular mouse cursor
-    QMessageBox::information(nullptr,
-                             "Segmentation functionality",
-                             "The seed point is outside of the image! Please choose a position inside the image!");
-    return;
-  }
-
-  IndexType seedIndex;
-  imageGeometry->WorldToIndex(seedPoint, seedIndex); // convert world coordinates to image indices
-
-  if (m_SeedpointValue > m_UPPERTHRESHOLD || m_SeedpointValue < m_LOWERTHRESHOLD)
-  {
-    QApplication::restoreOverrideCursor(); // reset cursor to be able to click ok with the regular mouse cursor
-    QMessageBox::information(
-      nullptr,
-      "Segmentation functionality",
-      "The seed point is outside the defined thresholds! Please set a new seed point or adjust the thresholds.");
-    MITK_INFO << "Mean: " << m_SeedPointValueMean;
-    return;
-  }
-
-  // Setting the direction of the regiongrowing. For dark structures e.g. the lung the regiongrowing
-  // is performed starting at the upper value going to the lower one
-  regionGrower->SetGrowingDirectionIsUpwards(m_CurrentRGDirectionIsUpwards);
-  regionGrower->SetInput(itkImage);
-  regionGrower->AddSeed(seedIndex);
-  // In some cases we have to subtract 1 for the lower threshold and add 1 to the upper.
-  // Otherwise no region growing is done. Maybe a bug in the ConnectiveAdaptiveThresholdFilter
-  mitk::ScalarType maxPixelValue = m_Controls.m_ThresholdSlider->maximum();
-  mitk::ScalarType minPixelValue = m_Controls.m_ThresholdSlider->minimum();
-
-  if ((m_LOWERTHRESHOLD - minPixelValue) >= 1)
-  {
-    regionGrower->SetLower(m_LOWERTHRESHOLD - 1);
-  }
-  else
-  {
-    regionGrower->SetLower(m_LOWERTHRESHOLD);
-  }
-
-  if ((maxPixelValue - m_UPPERTHRESHOLD) >= 1)
-  {
-    regionGrower->SetUpper(m_UPPERTHRESHOLD + 1);
-  }
-  else
-  {
-    regionGrower->SetUpper(m_UPPERTHRESHOLD);
-  }
-
-
-  try
-  {
-    regionGrower->Update();
-  }
-  catch (itk::ExceptionObject &exc)
-  {
-    QMessageBox errorInfo;
-    errorInfo.setWindowTitle("Adaptive RG Segmentation Functionality");
-    errorInfo.setIcon(QMessageBox::Critical);
-    errorInfo.setText("An error occurred during region growing!");
-    errorInfo.setDetailedText(exc.what());
-    errorInfo.exec();
-    return; // can't work
-  }
-  catch (...)
-  {
-    QMessageBox::critical(nullptr, "Adaptive RG Segmentation Functionality", "An error occurred during region growing!");
-    return;
-  }
-
-  mitk::Image::Pointer resultImage = mitk::ImportItkImage(regionGrower->GetOutput())->Clone();
-  // initialize slider
-  m_Controls.m_PreviewSlider->setMinimum(m_LOWERTHRESHOLD);
-
-  mitk::ScalarType max = m_SeedpointValue + resultImage->GetStatistics()->GetScalarValueMax();
-  if (max < m_UPPERTHRESHOLD)
-    m_Controls.m_PreviewSlider->setMaximum(max);
-  else
-    m_Controls.m_PreviewSlider->setMaximum(m_UPPERTHRESHOLD);
-
-  this->m_DetectedLeakagePoint = regionGrower->GetLeakagePoint();
-
-  if (m_CurrentRGDirectionIsUpwards)
-  {
-    m_Controls.m_PreviewSlider->setValue(m_SeedPointValueMean - 1);
-  }
-  else
-  {
-    m_Controls.m_PreviewSlider->setValue(m_SeedPointValueMean + 1);
-  }
-  this->m_SliderInitialized = true;
-
-  // create new node and then delete the old one if there is one
-  mitk::DataNode::Pointer newNode = mitk::DataNode::New();
-  newNode->SetData(resultImage);
-
-  // set some properties
-  newNode->SetProperty("name", mitk::StringProperty::New(m_NAMEFORLABLEDSEGMENTATIONIMAGE));
-  newNode->SetProperty("helper object", mitk::BoolProperty::New(true));
-  newNode->SetProperty("color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
-  newNode->SetProperty("layer", mitk::IntProperty::New(1));
-  newNode->SetProperty("opacity", mitk::FloatProperty::New(0.7));
-
-  // delete the old image, if there was one:
-  mitk::DataNode::Pointer binaryNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
-  m_DataStorage->Remove(binaryNode);
-
-  // now add result to data tree
-  m_DataStorage->Add(newNode, m_InputImageNode);
-
-  typename InputImageType::Pointer inputImageItk;
-  mitk::CastToItkImage<InputImageType>(resultImage, inputImageItk);
-  // volume rendering preview masking
-  typename ThresholdFilterType::Pointer thresholdFilter = ThresholdFilterType::New();
-  thresholdFilter->SetInput(inputImageItk);
-  thresholdFilter->SetInsideValue(1);
-  thresholdFilter->SetOutsideValue(0);
-
-  double sliderVal = this->m_Controls.m_PreviewSlider->value();
-  if (m_CurrentRGDirectionIsUpwards)
-  {
-    thresholdFilter->SetLowerThreshold(sliderVal);
-    thresholdFilter->SetUpperThreshold(itk::NumericTraits<TPixel>::max());
-  }
-  else
-  {
-    thresholdFilter->SetLowerThreshold(itk::NumericTraits<TPixel>::NonpositiveMin());
-    thresholdFilter->SetUpperThreshold(sliderVal);
-  }
-  thresholdFilter->SetInPlace(false);
-
-  typename MaskImageFilterType::Pointer maskFilter = MaskImageFilterType::New();
-  maskFilter->SetInput(inputImageItk);
-  maskFilter->SetInPlace(false);
-  maskFilter->SetMaskImage(thresholdFilter->GetOutput());
-  maskFilter->SetOutsideValue(0);
-  maskFilter->UpdateLargestPossibleRegion();
-
-  mitk::Image::Pointer mitkMask;
-  mitk::CastToMitkImage<InputImageType>(maskFilter->GetOutput(), mitkMask);
-  mitk::DataNode::Pointer maskedNode = mitk::DataNode::New();
-  maskedNode->SetData(mitkMask);
-
-  // set some properties
-  maskedNode->SetProperty("name", mitk::StringProperty::New(m_NAMEFORMASKEDSEGMENTATION));
-  maskedNode->SetProperty("helper object", mitk::BoolProperty::New(true));
-  maskedNode->SetProperty("color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
-  maskedNode->SetProperty("layer", mitk::IntProperty::New(1));
-  maskedNode->SetProperty("opacity", mitk::FloatProperty::New(0.0));
-
-  // delete the old image, if there was one:
-  mitk::DataNode::Pointer deprecatedMask = m_DataStorage->GetNamedNode(m_NAMEFORMASKEDSEGMENTATION);
-  m_DataStorage->Remove(deprecatedMask);
-
-  // now add result to data tree
-  m_DataStorage->Add(maskedNode, m_InputImageNode);
-
-  this->InitializeLevelWindow();
-
-  if (m_UseVolumeRendering)
-    this->EnableVolumeRendering(true);
-
-  m_UpdateSuggestedThreshold = true; // reset first stored threshold value
-  // Setting progress to finished
-  mitk::ProgressBar::GetInstance()->Progress(357);
-  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::InitializeLevelWindow()
-{
-  // get the preview from the datatree
-  mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
-
-  mitk::LevelWindow tempLevelWindow;
-  newNode->GetLevelWindow(tempLevelWindow, nullptr, "levelwindow");
-
-  mitk::ScalarType *level = new mitk::ScalarType(0.0);
-  mitk::ScalarType *window = new mitk::ScalarType(1.0);
-
-  int upper;
-  if (m_CurrentRGDirectionIsUpwards)
-  {
-    upper = m_UPPERTHRESHOLD - m_SeedpointValue;
-  }
-  else
-  {
-    upper = m_SeedpointValue - m_LOWERTHRESHOLD;
-  }
-
-  tempLevelWindow.SetRangeMinMax(mitk::ScalarType(0), mitk::ScalarType(upper));
-
-  // get the suggested threshold from the detected leakage-point and adjust the slider
-
-  if (m_CurrentRGDirectionIsUpwards)
-  {
-    this->m_Controls.m_PreviewSlider->setValue(m_SeedpointValue);
-    *level = m_UPPERTHRESHOLD - (m_SeedpointValue) + 0.5;
-  }
-  else
-  {
-    this->m_Controls.m_PreviewSlider->setValue(m_SeedpointValue);
-    *level = (m_SeedpointValue)-m_LOWERTHRESHOLD + 0.5;
-  }
-
-  tempLevelWindow.SetLevelWindow(*level, *window);
-  newNode->SetLevelWindow(tempLevelWindow, nullptr, "levelwindow");
-  // update the widgets
-  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-
-  m_SliderInitialized = true;
-
-  // inquiry need to fix bug#1828
-  static int lastSliderPosition = 0;
-  if ((this->m_SeedpointValue + this->m_DetectedLeakagePoint - 1) == lastSliderPosition)
-  {
-    this->ChangeLevelWindow(lastSliderPosition);
-  }
-  lastSliderPosition = this->m_SeedpointValue + this->m_DetectedLeakagePoint - 1;
-
-  if (m_UseVolumeRendering)
-    this->UpdateVolumeRenderingThreshold((int)(*level + 0.5)); // lower threshold for labeled image
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::ChangeLevelWindow(double newValue)
-{
-  if (m_SliderInitialized)
-  {
-    // do nothing, if no preview exists
-    mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
-    if (newNode.IsNull())
-      return;
-
-    mitk::LevelWindow tempLevelWindow;
-
-    newNode->GetLevelWindow(tempLevelWindow, nullptr, "levelwindow"); // get the levelWindow associated with the preview
-
-    mitk::ScalarType level; // = this->m_UPPERTHRESHOLD - newValue + 0.5;
-    mitk::ScalarType *window = new mitk::ScalarType(1);
-
-    // adjust the levelwindow according to the position of the slider (newvalue)
-    if (m_CurrentRGDirectionIsUpwards)
-    {
-      level = m_UPPERTHRESHOLD - newValue + 0.5;
-      tempLevelWindow.SetLevelWindow(level, *window);
-    }
-    else
-    {
-      level = newValue - m_LOWERTHRESHOLD + 0.5;
-      tempLevelWindow.SetLevelWindow(level, *window);
-    }
-
-    newNode->SetLevelWindow(tempLevelWindow, nullptr, "levelwindow");
-
-    if (m_UseVolumeRendering)
-      this->UpdateVolumeRenderingThreshold((int)(level - 0.5)); // lower threshold for labeled image
-
-    newNode->SetVisibility(true);
-    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-  }
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::DecreaseSlider()
-{
-  // moves the slider one step to the left, when the "-"-button is pressed
-  if (this->m_Controls.m_PreviewSlider->value() != this->m_Controls.m_PreviewSlider->minimum())
-  {
-    int newValue = this->m_Controls.m_PreviewSlider->value() - 1;
-    this->ChangeLevelWindow(newValue);
-    this->m_Controls.m_PreviewSlider->setValue(newValue);
-  }
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::IncreaseSlider()
-{
-  // moves the slider one step to the right, when the "+"-button is pressed
-  if (this->m_Controls.m_PreviewSlider->value() != this->m_Controls.m_PreviewSlider->maximum())
-  {
-    int newValue = this->m_Controls.m_PreviewSlider->value() + 1;
-    this->ChangeLevelWindow(newValue);
-    this->m_Controls.m_PreviewSlider->setValue(newValue);
-  }
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::ConfirmSegmentation()
-{
-  // get image node
-  if (m_InputImageNode.IsNull())
-  {
-    QMessageBox::critical(nullptr, "Adaptive region growing functionality", "Please specify the image in Datamanager!");
-    return;
-  }
-  // get image data
-  mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image *>(m_InputImageNode->GetData());
-  if (orgImage.IsNull())
-  {
-    QMessageBox::critical(nullptr, "Adaptive region growing functionality", "No Image found!");
-    return;
-  }
-  // get labeled segmentation
-  mitk::Image::Pointer labeledSeg =
-    (mitk::Image *)m_DataStorage->GetNamedObject<mitk::Image>(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
-  if (labeledSeg.IsNull())
-  {
-    QMessageBox::critical(nullptr, "Adaptive region growing functionality", "No Segmentation Preview found!");
-    return;
-  }
-
-  mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
-  if (newNode.IsNull())
-    return;
-
-  QmitkConfirmSegmentationDialog dialog;
-  QString segName = QString::fromStdString(m_RegionGrow3DTool->GetCurrentSegmentationName());
-
-  dialog.SetSegmentationName(segName);
-  int result = dialog.exec();
-
-  switch (result)
-  {
-    case QmitkConfirmSegmentationDialog::CREATE_NEW_SEGMENTATION:
-      m_RegionGrow3DTool->SetOverwriteExistingSegmentation(false);
-      break;
-    case QmitkConfirmSegmentationDialog::OVERWRITE_SEGMENTATION:
-      m_RegionGrow3DTool->SetOverwriteExistingSegmentation(true);
-      break;
-    case QmitkConfirmSegmentationDialog::CANCEL_SEGMENTATION:
-      return;
-  }
-
-  mitk::Image::Pointer img = dynamic_cast<mitk::Image *>(newNode->GetData());
-  AccessByItk(img, ITKThresholding);
-
-  // disable volume rendering preview after the segmentation node was created
-  this->EnableVolumeRendering(false);
-  newNode->SetVisibility(false);
-  m_Controls.m_cbVolumeRendering->setChecked(false);
-  // TODO disable slider etc...
-
-  if (m_RegionGrow3DTool.IsNotNull())
-  {
-    m_RegionGrow3DTool->ConfirmSegmentation();
-  }
-}
-
-template <typename TPixel, unsigned int VImageDimension>
-void QmitkAdaptiveRegionGrowingToolGUI::ITKThresholding(itk::Image<TPixel, VImageDimension> *itkImage)
-{
-  mitk::Image::Pointer originalSegmentation =
-    dynamic_cast<mitk::Image *>(this->m_RegionGrow3DTool->GetTargetSegmentationNode()->GetData());
-
-  const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
-
-  if (!originalSegmentation->GetTimeGeometry()->IsValidTimePoint(timePoint))
-    mitkThrow() << "Segmentation is not defined for specified time point. Time point: " << timePoint;
-
-  int timeStep = static_cast<int>(originalSegmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint));
-
-
-  if (originalSegmentation)
-  {
-    typedef itk::Image<TPixel, VImageDimension> InputImageType;
-    typedef itk::Image<mitk::Tool::DefaultSegmentationDataType, VImageDimension> SegmentationType;
-
-    // select single 3D volume if we have more than one time step
-    typename SegmentationType::Pointer originalSegmentationInITK = SegmentationType::New();
-    if (originalSegmentation->GetTimeGeometry()->CountTimeSteps() > 1)
-    {
-      mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
-      timeSelector->SetInput(originalSegmentation);
-      timeSelector->SetTimeNr(timeStep);
-      timeSelector->UpdateLargestPossibleRegion();
-      CastToItkImage(timeSelector->GetOutput(), originalSegmentationInITK);
-    }
-    else // use original
-    {
-      CastToItkImage(originalSegmentation, originalSegmentationInITK);
-    }
-
-    // Fill current preiview image in segmentation image
-    originalSegmentationInITK->FillBuffer(0);
-    itk::ImageRegionIterator<SegmentationType> itOutput(originalSegmentationInITK,
-                                                        originalSegmentationInITK->GetLargestPossibleRegion());
-    itk::ImageRegionIterator<InputImageType> itInput(itkImage, itkImage->GetLargestPossibleRegion());
-    itOutput.GoToBegin();
-    itInput.GoToBegin();
-
-    // calculate threhold from slider value
-    int currentTreshold = 0;
-    if (m_CurrentRGDirectionIsUpwards)
-    {
-      currentTreshold = m_UPPERTHRESHOLD - m_Controls.m_PreviewSlider->value() + 1;
-    }
-    else
-    {
-      currentTreshold = m_Controls.m_PreviewSlider->value() - m_LOWERTHRESHOLD;
-    }
-
-    // iterate over image and set pixel in segmentation according to thresholded labeled image
-    while (!itOutput.IsAtEnd() && !itInput.IsAtEnd())
-    {
-      // Use threshold slider to determine if pixel is set to 1
-      if (itInput.Value() != 0 && itInput.Value() >= static_cast<typename itk::ImageRegionIterator<InputImageType>::PixelType>(currentTreshold))
-      {
-        itOutput.Set(1);
-      }
-
-      ++itOutput;
-      ++itInput;
-    }
-
-    // combine current working segmentation image with our region growing result
-    originalSegmentation->SetVolume((void *)(originalSegmentationInITK->GetPixelContainer()->GetBufferPointer()),
-                                    timeStep);
-
-    originalSegmentation->Modified();
-    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-  }
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::EnableControls(bool enable)
-{
-  if (m_RegionGrow3DTool.IsNull())
-    return;
-
-  // Check if seed point is already set, if not leave RunSegmentation disabled
-  // if even m_DataStorage is nullptr leave node nullptr
-  mitk::DataNode::Pointer node = m_RegionGrow3DTool->GetPointSetNode();
-  if (node.IsNull())
-  {
-    this->m_Controls.m_pbRunSegmentation->setEnabled(false);
-  }
-  else
-  {
-    this->m_Controls.m_pbRunSegmentation->setEnabled(enable);
-  }
-
-  // Check if a segmentation exists, if not leave segmentation dependent disabled.
-  // if even m_DataStorage is nullptr leave node nullptr
-  node = m_DataStorage ? m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE) : nullptr;
-  if (node.IsNull())
-  {
-    this->m_Controls.m_PreviewSlider->setEnabled(false);
-    this->m_Controls.m_pbConfirmSegementation->setEnabled(false);
-  }
-  else
-  {
-    this->m_Controls.m_PreviewSlider->setEnabled(enable);
-    this->m_Controls.m_pbConfirmSegementation->setEnabled(enable);
-  }
-
-  this->m_Controls.m_cbVolumeRendering->setEnabled(enable);
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::EnableVolumeRendering(bool enable)
-{
-  mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode(m_NAMEFORMASKEDSEGMENTATION);
-
-  if (node.IsNull())
-    return;
-
-  node->SetBoolProperty("volumerendering", enable);
-
-  double val = this->m_Controls.m_PreviewSlider->value();
-  this->ChangeLevelWindow(val);
-
-  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::UpdateVolumeRenderingThreshold(int)
-{
-  typedef short PixelType;
-  typedef itk::Image<PixelType, 3> InputImageType;
-  typedef itk::BinaryThresholdImageFilter<InputImageType, InputImageType> ThresholdFilterType;
-  typedef itk::MaskImageFilter<InputImageType, InputImageType, InputImageType> MaskImageFilterType;
-
-  mitk::DataNode::Pointer grownImageNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
-  mitk::Image::Pointer grownImage = dynamic_cast<mitk::Image *>(grownImageNode->GetData());
-
-  if (!grownImage)
-  {
-    MITK_ERROR << "Missing data node for labeled segmentation image.";
-    return;
-  }
-
-  InputImageType::Pointer itkGrownImage;
-  mitk::CastToItkImage(grownImage, itkGrownImage);
-
-  ThresholdFilterType::Pointer thresholdFilter = ThresholdFilterType::New();
-  thresholdFilter->SetInput(itkGrownImage);
-  thresholdFilter->SetInPlace(false);
-
-  double sliderVal = this->m_Controls.m_PreviewSlider->value();
-  PixelType threshold = itk::NumericTraits<PixelType>::min();
-  if (m_CurrentRGDirectionIsUpwards)
-  {
-    threshold = static_cast<PixelType>(m_UPPERTHRESHOLD - sliderVal + 0.5);
-
-    thresholdFilter->SetLowerThreshold(threshold);
-    thresholdFilter->SetUpperThreshold(itk::NumericTraits<PixelType>::max());
-  }
-  else
-  {
-    threshold = sliderVal - m_LOWERTHRESHOLD + 0.5;
-
-    thresholdFilter->SetLowerThreshold(itk::NumericTraits<PixelType>::min());
-    thresholdFilter->SetUpperThreshold(threshold);
-  }
-  thresholdFilter->UpdateLargestPossibleRegion();
-
-  MaskImageFilterType::Pointer maskFilter = MaskImageFilterType::New();
-  maskFilter->SetInput(itkGrownImage);
-  maskFilter->SetInPlace(false);
-  maskFilter->SetMaskImage(thresholdFilter->GetOutput());
-  maskFilter->SetOutsideValue(0);
-  maskFilter->UpdateLargestPossibleRegion();
-
-  mitk::Image::Pointer mitkMaskedImage;
-  mitk::CastToMitkImage<InputImageType>(maskFilter->GetOutput(), mitkMaskedImage);
-  mitk::DataNode::Pointer maskNode = m_DataStorage->GetNamedNode(m_NAMEFORMASKEDSEGMENTATION);
-  maskNode->SetData(mitkMaskedImage);
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::UseVolumeRendering(bool on)
-{
-  m_UseVolumeRendering = on;
-
-  this->EnableVolumeRendering(on);
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::SetLowerThresholdValue(double lowerThreshold)
-{
-  m_LOWERTHRESHOLD = lowerThreshold;
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::SetUpperThresholdValue(double upperThreshold)
-{
-  m_UPPERTHRESHOLD = upperThreshold;
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::Deactivated()
-{
-  // make the segmentation preview node invisible
-  mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
-  if (node.IsNotNull())
-  {
-    node->SetVisibility(false);
-  }
-
-  // disable volume rendering preview after the segmentation node was created
-  this->EnableVolumeRendering(false);
-  m_Controls.m_cbVolumeRendering->setChecked(false);
-}
-
-void QmitkAdaptiveRegionGrowingToolGUI::Activated()
-{
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h
deleted file mode 100644
index 79f848ea27..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h
+++ /dev/null
@@ -1,229 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-#ifndef QMITK_QmitkAdaptiveRegionGrowingToolGUI_H
-#define QMITK_QmitkAdaptiveRegionGrowingToolGUI_H
-
-#include "itkImage.h"
-#include "mitkDataStorage.h"
-#include "mitkGeometry3D.h"
-#include "mitkPointSet.h"
-
-#include "qwidget.h"
-#include "ui_QmitkAdaptiveRegionGrowingToolGUIControls.h"
-
-#include <MitkSegmentationUIExports.h>
-
-#include "QmitkToolGUI.h"
-
-#include "mitkAdaptiveRegionGrowingTool.h"
-
-class DataNode;
-class QmitkAdaptiveRegionGrowingToolGUIControls;
-
-/*!
-*
-* \brief QmitkAdaptiveRegionGrowingToolGUI
-*
-* Adaptive Region Growing View class of the segmentation.
-*
-*/
-
-class MITKSEGMENTATIONUI_EXPORT QmitkAdaptiveRegionGrowingToolGUI : public QmitkToolGUI
-{
-  Q_OBJECT
-
-public:
-  /**
-   * @brief mitkClassMacro
-   */
-  mitkClassMacro(QmitkAdaptiveRegionGrowingToolGUI, QmitkToolGUI);
-
-  itkFactorylessNewMacro(Self);
-
-  itkCloneMacro(Self);
-
-    QmitkAdaptiveRegionGrowingToolGUI(QWidget *parent = nullptr);
-
-  /** \brief Method to create the connections for the component. This Method is obligatory even if no connections is
-   * needed*/
-  virtual void CreateConnections();
-
-  ///** \brief Method to set the default data storage.*/
-  virtual void SetDataStorage(mitk::DataStorage *dataStorage);
-
-  /**
-   * @brief Method to set the name of a data node.
-   * @param labledSegmentation Name of the labeled segmentation
-   * @param binaryImage Name of the binary image
-   * @param surface Name of the surface
-   * @param maskedSegmentation
-   */
-  void SetDataNodeNames(std::string labledSegmentation,
-                        std::string binaryImage,
-                        /*std::string vesselTree,*/ std::string surface,
-                        std::string maskedSegmentation);
-
-  /**
-   * @brief Method to enable/disable controls for region growing
-   *
-   * This method checks if a seed point is set and a segmentation exists.
-   * @param enable enable/disable controls
-   */
-  void EnableControls(bool enable);
-
-  /**
-   * @brief Method to set the input image node
-   * @param node data node
-   */
-  void SetInputImageNode(mitk::DataNode *node);
-
-  void Deactivated();
-  void Activated();
-
-  /**
-  * @brief The created GUI from the .ui-File. This Attribute is obligatory
-  */
-  Ui::QmitkAdaptiveRegionGrowingToolGUIControls m_Controls;
-
-protected slots:
-
-  /**
-   * @brief Method to start the segmentation
-   *
-   * This method is called, when the "Start Segmentation" button is clicked.
-   */
-  void RunSegmentation();
-
-  /**
-   * @brief Method to change the level window
-   *
-   * This method is called, when the level window slider is changed via the slider in the control widget
-   * @param newValue new value
-   */
-  void ChangeLevelWindow(double newValue);
-
-  /**
-   * @brief Method to increase the preview slider
-   *
-   * This method is called, when the + button is clicked and increases the value by 1
-   */
-  void IncreaseSlider();
-
-  /**
-   * @brief Method to decrease the preview slider
-   *
-   * This method is called, when the - button is clicked and decreases the value by 1
-   */
-  void DecreaseSlider();
-
-  /**
-   * @brief Method to confirm the preview segmentation
-   *
-   * This method is called, when the "Confirm Segmentation" button is clicked.
-   */
-  void ConfirmSegmentation();
-
-  /**
-   * @brief Method to switch the volume rendering on/off
-   * @param on
-   */
-  void UseVolumeRendering(bool on);
-
-  /**
-   * @brief Method to set the lower threshold
-   *
-   * This method is called, when the minimum threshold slider has changed
-   * @param lowerThreshold lower threshold
-   */
-  void SetLowerThresholdValue(double lowerThreshold);
-
-  /**
-   * @brief Method to set upper threshold
-   *
-   * This Method is called, when the maximum threshold slider has changed
-   * @param upperThreshold upper threshold
-   */
-  void SetUpperThresholdValue(double upperThreshold);
-
-  /**
-   * @brief Method to determine which tool to activate
-   *
-   * This method listens to the tool manager and activates this tool if requested otherwise disables this view
-   */
-  void OnNewToolAssociated(mitk::Tool *);
-
-protected:
-  mitk::AdaptiveRegionGrowingTool::Pointer m_RegionGrow3DTool;
-
-  /** \brief Destructor. */
-  ~QmitkAdaptiveRegionGrowingToolGUI() override;
-
-  mitk::DataStorage *m_DataStorage;
-
-  mitk::DataNode::Pointer m_InputImageNode;
-
-  /**
-   * @brief Method to calculate parameter settings, when a seed point is set
-   */
-  void OnPointAdded();
-
-   /**
-   * @brief Method to extract a 3D image based on a given time point that can be taken from the SliceNavigationController
-   *
-   * This ensures that the seed point is taken from the current selected 3D image
-   */
-  mitk::Image::ConstPointer GetImageByTimePoint(const mitk::Image *image,
-                                                          mitk::TimePointType timePoint) const;
-
-private:
-  std::string m_NAMEFORORGIMAGE;
-  std::string m_NAMEFORLABLEDSEGMENTATIONIMAGE;
-  std::string m_NAMEFORBINARYIMAGE;
-  std::string m_NAMEFORSURFACE;
-  std::string m_NAMEFORMASKEDSEGMENTATION;
-
-  mitk::ScalarType m_LOWERTHRESHOLD; // Hounsfield value
-  mitk::ScalarType m_UPPERTHRESHOLD; // Hounsfield value
-  mitk::ScalarType m_SeedPointValueMean;
-
-  void RemoveHelperNodes();
-
-  int m_DetectedLeakagePoint;
-
-  bool m_CurrentRGDirectionIsUpwards; // defines fixed threshold (true = LOWERTHRESHOLD fixed, false = UPPERTHRESHOLD
-                                      // fixed)
-
-  int m_SeedpointValue;
-  bool m_SliderInitialized;
-  bool m_UseVolumeRendering;
-  bool m_UpdateSuggestedThreshold;
-  float m_SuggestedThValue;
-
-  long m_PointSetAddObserverTag;
-  long m_PointSetMoveObserverTag;
-
-  template <typename TPixel, unsigned int VImageDimension>
-  void StartRegionGrowing(const itk::Image<TPixel, VImageDimension> *itkImage,
-                          const mitk::BaseGeometry *imageGeometry,
-                          const mitk::PointSet::PointType seedPoint);
-
-  template <typename TPixel, unsigned int VImageDimension>
-  void ITKThresholding(itk::Image<TPixel, VImageDimension> *inputImage);
-
-  void InitializeLevelWindow();
-
-  void EnableVolumeRendering(bool enable);
-
-  void UpdateVolumeRenderingThreshold(int thValue);
-};
-
-#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUIControls.ui b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUIControls.ui
deleted file mode 100644
index 2b91deefe8..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUIControls.ui
+++ /dev/null
@@ -1,227 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>QmitkAdaptiveRegionGrowingToolGUIControls</class>
- <widget class="QWidget" name="QmitkAdaptiveRegionGrowingToolGUIControls">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>264</width>
-    <height>171</height>
-   </rect>
-  </property>
-  <property name="sizePolicy">
-   <sizepolicy hsizetype="Ignored" vsizetype="Minimum">
-    <horstretch>0</horstretch>
-    <verstretch>0</verstretch>
-   </sizepolicy>
-  </property>
-  <property name="minimumSize">
-   <size>
-    <width>0</width>
-    <height>0</height>
-   </size>
-  </property>
-  <property name="windowTitle">
-   <string>QmitkAdaptiveRegionGrowingWidget</string>
-  </property>
-  <property name="toolTip">
-   <string>Move to adjust the segmentation</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <property name="margin">
-    <number>0</number>
-   </property>
-   <item>
-    <widget class="QLabel" name="m_lblSetSeedpoint">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="text">
-      <string>Shift+Click to place seedpoint</string>
-     </property>
-     <property name="margin">
-      <number>0</number>
-     </property>
-    </widget>
-   </item>
-   <item>
-    <widget class="QGroupBox" name="groupBox">
-     <property name="title">
-      <string>Define thresholds:</string>
-     </property>
-     <property name="flat">
-      <bool>true</bool>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_3">
-      <property name="leftMargin">
-       <number>0</number>
-      </property>
-      <property name="topMargin">
-       <number>6</number>
-      </property>
-      <property name="rightMargin">
-       <number>0</number>
-      </property>
-      <property name="bottomMargin">
-       <number>0</number>
-      </property>
-      <item>
-       <widget class="ctkRangeWidget" name="m_ThresholdSlider" native="true"/>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout">
-     <item>
-      <spacer name="horizontalSpacer">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item>
-      <widget class="QPushButton" name="m_pbRunSegmentation">
-       <property name="enabled">
-        <bool>false</bool>
-       </property>
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="font">
-        <font/>
-       </property>
-       <property name="toolTip">
-        <string>Press to start the segmentation of the tubular structure.</string>
-       </property>
-       <property name="text">
-        <string>Run Segmentation</string>
-       </property>
-       <property name="shortcut">
-        <string>Alt+R</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QCheckBox" name="m_cbVolumeRendering">
-       <property name="enabled">
-        <bool>false</bool>
-       </property>
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="toolTip">
-        <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
-&lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
-p, li { white-space: pre-wrap; }
-&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;&quot;&gt;
-&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:8pt;&quot;&gt;Enable/disable GPU volume rendering for the segmentation preview.&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-       </property>
-       <property name="layoutDirection">
-        <enum>Qt::LeftToRight</enum>
-       </property>
-       <property name="text">
-        <string>3D preview</string>
-       </property>
-       <property name="checked">
-        <bool>false</bool>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <spacer name="horizontalSpacer_2">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <widget class="QGroupBox" name="groupBox_2">
-     <property name="title">
-      <string>Adapt Region Growing:</string>
-     </property>
-     <property name="flat">
-      <bool>true</bool>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_2">
-      <property name="leftMargin">
-       <number>0</number>
-      </property>
-      <property name="topMargin">
-       <number>6</number>
-      </property>
-      <property name="rightMargin">
-       <number>0</number>
-      </property>
-      <property name="bottomMargin">
-       <number>0</number>
-      </property>
-      <item>
-       <widget class="ctkSliderWidget" name="m_PreviewSlider" native="true"/>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <widget class="QPushButton" name="m_pbConfirmSegementation">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
-     <property name="font">
-      <font/>
-     </property>
-     <property name="toolTip">
-      <string>Press to confirm the segmentation and calculate 3D representation.</string>
-     </property>
-     <property name="text">
-      <string>&amp;Confirm Segmentation</string>
-     </property>
-     <property name="shortcut">
-      <string>Alt+C</string>
-     </property>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <layoutdefault spacing="6" margin="11"/>
- <customwidgets>
-  <customwidget>
-   <class>ctkRangeWidget</class>
-   <extends>QWidget</extends>
-   <header location="global">ctkRangeWidget.h</header>
-   <container>1</container>
-  </customwidget>
-  <customwidget>
-   <class>ctkSliderWidget</class>
-   <extends>QWidget</extends>
-   <header location="global">ctkSliderWidget.h</header>
-   <container>1</container>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
deleted file mode 100644
index 863e753c08..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include "QmitkAutoMLSegmentationToolGUIBase.h"
-#include "mitkAutoMLSegmentationWithPreviewTool.h"
-
-#include <qboxlayout.h>
-
-QmitkAutoMLSegmentationToolGUIBase::QmitkAutoMLSegmentationToolGUIBase() : QmitkAutoSegmentationToolGUIBase(false)
-{
-  auto enableMLSelectedDelegate = [this](bool enabled)
-  {
-    bool result = enabled;
-    auto tool = this->GetConnectedToolAs<mitk::AutoMLSegmentationWithPreviewTool>();
-    if (nullptr != tool)
-    {
-      result = !tool->GetSelectedLabels().empty() && enabled;
-    }
-    else
-    {
-      result = false;
-    }
-
-    return result;
-  };
-
-  m_EnableConfirmSegBtnFnc = enableMLSelectedDelegate;
-}
-
-void QmitkAutoMLSegmentationToolGUIBase::InitializeUI(QBoxLayout* mainLayout)
-{
-  m_LabelSelectionList = new QmitkSimpleLabelSetListWidget(this);
-  m_LabelSelectionList->setObjectName(QString::fromUtf8("m_LabelSelectionList"));
-  QSizePolicy sizePolicy2(QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
-  sizePolicy2.setHorizontalStretch(0);
-  sizePolicy2.setVerticalStretch(0);
-  sizePolicy2.setHeightForWidth(m_LabelSelectionList->sizePolicy().hasHeightForWidth());
-  m_LabelSelectionList->setSizePolicy(sizePolicy2);
-  m_LabelSelectionList->setMaximumSize(QSize(10000000, 10000000));
-
-  mainLayout->addWidget(m_LabelSelectionList);
-
-  connect(m_LabelSelectionList, &QmitkSimpleLabelSetListWidget::SelectedLabelsChanged, this, &QmitkAutoMLSegmentationToolGUIBase::OnLabelSelectionChanged);
-
-  Superclass::InitializeUI(mainLayout);
-}
-
-void QmitkAutoMLSegmentationToolGUIBase::OnLabelSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels)
-{
-  auto tool = this->GetConnectedToolAs<mitk::AutoMLSegmentationWithPreviewTool>();
-  if (nullptr != tool)
-  {
-    mitk::AutoMLSegmentationWithPreviewTool::SelectedLabelVectorType labelIDs;
-    for (const auto& label : selectedLabels)
-    {
-      labelIDs.push_back(label->GetValue());
-    }
-
-    tool->SetSelectedLabels(labelIDs);
-    tool->UpdatePreview();
-    this->EnableWidgets(true); //used to actualize the ConfirmSeg btn via the delegate;
-  }
-}
-
-void QmitkAutoMLSegmentationToolGUIBase::EnableWidgets(bool enabled)
-{
-  Superclass::EnableWidgets(enabled);
-  if (nullptr != m_LabelSelectionList)
-  {
-    m_LabelSelectionList->setEnabled(enabled);
-  }
-}
-
-void QmitkAutoMLSegmentationToolGUIBase::SetLabelSetPreview(const mitk::LabelSetImage* preview)
-{
-  if (nullptr != m_LabelSelectionList)
-  {
-    m_LabelSelectionList->SetLabelSetImage(preview);
-  }
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
deleted file mode 100644
index 5ca33cd4e2..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
+++ /dev/null
@@ -1,157 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include "QmitkAutoSegmentationToolGUIBase.h"
-
-#include <qcheckbox.h>
-#include <qpushbutton.h>
-#include <qboxlayout.h>
-#include <qlabel.h>
-#include <QApplication>
-
-bool DefaultEnableConfirmSegBtnFunction(bool enabled)
-{
-  return enabled;
-}
-
-QmitkAutoSegmentationToolGUIBase::QmitkAutoSegmentationToolGUIBase(bool mode2D) : QmitkToolGUI(), m_EnableConfirmSegBtnFnc(DefaultEnableConfirmSegBtnFunction), m_Mode2D(mode2D)
-{
-  connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
-}
-
-QmitkAutoSegmentationToolGUIBase::~QmitkAutoSegmentationToolGUIBase()
-{
-  if (m_Tool.IsNotNull())
-  {
-    m_Tool->CurrentlyBusy -= mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
-  }
-}
-
-void QmitkAutoSegmentationToolGUIBase::OnNewToolAssociated(mitk::Tool *tool)
-{
-  if (m_Tool.IsNotNull())
-  {
-    this->DisconnectOldTool(m_Tool);
-  }
-
-  m_Tool = dynamic_cast<mitk::AutoSegmentationWithPreviewTool*>(tool);
-
-  if (nullptr == m_MainLayout)
-  {
-    // create the visible widgets
-    m_MainLayout = new QVBoxLayout(this);
-    m_ConfirmSegBtn = new QPushButton("Confirm Segmentation", this);
-    connect(m_ConfirmSegBtn, SIGNAL(clicked()), this, SLOT(OnAcceptPreview()));
-
-    m_CheckProcessAll = new QCheckBox("Process all time steps", this);
-    m_CheckProcessAll->setChecked(false);
-    m_CheckProcessAll->setToolTip("Process all time steps of the dynamic segmentation and not just the currently visible time step.");
-    m_CheckProcessAll->setVisible(!m_Mode2D);
-    //remark: keept m_CheckProcessAll deactivated in 2D because in this refactoring
-    //it should be kept to the status quo and it was not clear how interpolation
-    //would behave. As soon as it is sorted out we can remove that "feature switch"
-    //or the comment.
-
-    m_CheckCreateNew = new QCheckBox("Create as new segmentation", this);
-    m_CheckCreateNew->setChecked(false);
-    m_CheckCreateNew->setToolTip("Add the confirmed segmentation as a new segmentation instead of overwriting the currently selected.");
-    m_CheckCreateNew->setVisible(!m_Mode2D);
-    //remark: keept m_CheckCreateNew deactivated in 2D because in this refactoring
-    //it should be kept to the status quo and it was not clear how interpolation
-    //would behave. As soon as it is sorted out we can remove that "feature switch"
-    //or the comment.
-
-    this->InitializeUI(m_MainLayout);
-
-    m_MainLayout->addWidget(m_ConfirmSegBtn);
-    m_MainLayout->addWidget(m_CheckProcessAll);
-    m_MainLayout->addWidget(m_CheckCreateNew);
-  }
-
-  if (m_Tool.IsNotNull())
-  {
-    this->ConnectNewTool(m_Tool);
-  }
-}
-
-void QmitkAutoSegmentationToolGUIBase::OnAcceptPreview()
-{
-  if (m_Tool.IsNotNull())
-  {
-    if (m_CheckCreateNew->isChecked())
-    {
-      m_Tool->SetOverwriteExistingSegmentation(false);
-    }
-    else
-    {
-      m_Tool->SetOverwriteExistingSegmentation(true);
-    }
-
-    m_Tool->SetCreateAllTimeSteps(m_CheckProcessAll->isChecked());
-
-    m_ConfirmSegBtn->setEnabled(false);
-    m_Tool->ConfirmSegmentation();
-  }
-}
-
-void QmitkAutoSegmentationToolGUIBase::DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool)
-{
-  oldTool->CurrentlyBusy -= mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
-}
-
-void QmitkAutoSegmentationToolGUIBase::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
-{
-  newTool->CurrentlyBusy +=
-    mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
-
-  newTool->SetOverwriteExistingSegmentation(true);
-  m_CheckProcessAll->setVisible(newTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps() > 1);
-
-  this->EnableWidgets(true);
-}
-
-void QmitkAutoSegmentationToolGUIBase::InitializeUI(QBoxLayout* /*mainLayout*/)
-{
-  //default implementation does nothing
-}
-
-void QmitkAutoSegmentationToolGUIBase::BusyStateChanged(bool isBusy)
-{
-  if (isBusy)
-  {
-    QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
-  }
-  else
-  {
-    QApplication::restoreOverrideCursor();
-  }
-  this->EnableWidgets(!isBusy);
- }
-
-void QmitkAutoSegmentationToolGUIBase::EnableWidgets(bool enabled)
-{
-  if (nullptr != m_MainLayout)
-  {
-    if (nullptr != m_ConfirmSegBtn)
-    {
-      m_ConfirmSegBtn->setEnabled(m_EnableConfirmSegBtnFnc(enabled));
-    }
-    if (nullptr != m_CheckProcessAll)
-    {
-      m_CheckProcessAll->setEnabled(enabled);
-    }
-    if (nullptr != m_CheckCreateNew)
-    {
-      m_CheckCreateNew->setEnabled(enabled);
-    }
-  }
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.cpp
index 930eacadb7..f6231dea49 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.cpp
@@ -1,187 +1,187 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkBinaryThresholdToolGUIBase.h"
 
 #include "mitkBinaryThresholdBaseTool.h"
 #include "mitkBinaryThresholdTool.h"
 
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qslider.h>
 #include <QApplication>
 
-QmitkBinaryThresholdToolGUIBase::QmitkBinaryThresholdToolGUIBase(bool ulMode) : QmitkAutoSegmentationToolGUIBase(false), m_ULMode(ulMode)
+QmitkBinaryThresholdToolGUIBase::QmitkBinaryThresholdToolGUIBase(bool ulMode) : QmitkSegWithPreviewToolGUIBase(false), m_ULMode(ulMode)
 {
 }
 
 QmitkBinaryThresholdToolGUIBase::~QmitkBinaryThresholdToolGUIBase()
 {
   auto tool = this->GetConnectedToolAs<mitk::BinaryThresholdBaseTool>();
 
   if (nullptr != tool)
   {
     tool->IntervalBordersChanged -=
       mitk::MessageDelegate3<QmitkBinaryThresholdToolGUIBase, double, double, bool>(
         this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingIntervalBordersChanged);
     tool->ThresholdingValuesChanged -=
       mitk::MessageDelegate2<QmitkBinaryThresholdToolGUIBase, mitk::ScalarType, mitk::ScalarType>(
         this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingValuesChanged);
   }
 }
 
 void QmitkBinaryThresholdToolGUIBase::OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat)
 {
   m_InternalUpdate = true;
 
   if (m_ULMode)
   {
     if (!isFloat)
     {
       m_ThresholdRange->setRange(int(lower), int(upper));
       m_ThresholdRange->setSingleStep(1);
       m_ThresholdRange->setDecimals(0);
     }
     else
     {
       m_ThresholdRange->setRange(lower, upper);
     }
   }
   else
   {
     if (!isFloat)
     {
       m_ThresholdSlider->setRange(int(lower), int(upper));
       m_ThresholdSlider->setSingleStep(1);
       m_ThresholdSlider->setDecimals(0);
     }
     else
     {
       m_ThresholdSlider->setRange(lower, upper);
     }
   }
 
   m_InternalUpdate = false;
 }
 
 void QmitkBinaryThresholdToolGUIBase::OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper)
 {
   if (m_ULMode)
   {
     m_ThresholdRange->setValues(lower, upper);
   }
   else
   {
     m_ThresholdSlider->setValue(lower);
   }
 }
 
 void QmitkBinaryThresholdToolGUIBase::OnThresholdRangeChanged(double min, double max)
 {
   auto tool = this->GetConnectedToolAs<mitk::BinaryThresholdBaseTool>();
 
   if (nullptr != tool && !m_InternalUpdate)
   {
     tool->SetThresholdValues(min, max);
   }
 }
 
 void QmitkBinaryThresholdToolGUIBase::OnThresholdSliderChanged(double value)
 {
   auto tool = this->GetConnectedToolAs<mitk::BinaryThresholdTool>();
 
   if (nullptr != tool && !m_InternalUpdate)
   {
     tool->SetThresholdValue(value);
   }
 }
 
-void QmitkBinaryThresholdToolGUIBase::DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool)
+void QmitkBinaryThresholdToolGUIBase::DisconnectOldTool(mitk::SegWithPreviewTool* oldTool)
 {
   Superclass::DisconnectOldTool(oldTool);
 
   auto tool = dynamic_cast<mitk::BinaryThresholdBaseTool*>(oldTool);
 
   if (nullptr != tool)
   {
     tool->IntervalBordersChanged -=
       mitk::MessageDelegate3<QmitkBinaryThresholdToolGUIBase, double, double, bool>(
         this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingIntervalBordersChanged);
     tool->ThresholdingValuesChanged -=
       mitk::MessageDelegate2<QmitkBinaryThresholdToolGUIBase, mitk::ScalarType, mitk::ScalarType>(
         this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingValuesChanged);
   }
 }
 
-void QmitkBinaryThresholdToolGUIBase::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
+void QmitkBinaryThresholdToolGUIBase::ConnectNewTool(mitk::SegWithPreviewTool* newTool)
 {
   Superclass::ConnectNewTool(newTool);
 
   auto tool = dynamic_cast<mitk::BinaryThresholdBaseTool*>(newTool);
 
   if (nullptr != tool)
   {
     tool->IntervalBordersChanged +=
       mitk::MessageDelegate3<QmitkBinaryThresholdToolGUIBase, double, double, bool>(
         this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingIntervalBordersChanged);
     tool->ThresholdingValuesChanged +=
       mitk::MessageDelegate2<QmitkBinaryThresholdToolGUIBase, mitk::ScalarType, mitk::ScalarType>(
         this, &QmitkBinaryThresholdToolGUIBase::OnThresholdingValuesChanged);
   }
 }
 
 void QmitkBinaryThresholdToolGUIBase::InitializeUI(QBoxLayout* mainLayout)
 {
   QLabel* label = new QLabel("Threshold :", this);
   QFont f = label->font();
   f.setBold(false);
   label->setFont(f);
   mainLayout->addWidget(label);
 
   QBoxLayout* layout = new QHBoxLayout();
 
   if (m_ULMode)
   {
     m_ThresholdRange = new ctkRangeWidget();
     connect(
       m_ThresholdRange, SIGNAL(valuesChanged(double, double)), this, SLOT(OnThresholdRangeChanged(double, double)));
     layout->addWidget(m_ThresholdRange);
     m_ThresholdRange->setSingleStep(0.01);
   }
   else
   {
     m_ThresholdSlider = new ctkSliderWidget();
     connect(
       m_ThresholdSlider, SIGNAL(valueChanged(double)), this, SLOT(OnThresholdSliderChanged(double)));
     layout->addWidget(m_ThresholdSlider);
     m_ThresholdSlider->setSingleStep(0.01);
   }
 
   mainLayout->addLayout(layout);
 
   Superclass::InitializeUI(mainLayout);
 }
 
 void QmitkBinaryThresholdToolGUIBase::BusyStateChanged(bool value)
 {
   Superclass::BusyStateChanged(value);
 
   if (m_ThresholdRange)
   {
     m_ThresholdRange->setEnabled(!value);
   }
 
   if (m_ThresholdSlider)
   {
     m_ThresholdSlider->setEnabled(!value);
   }
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.h b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.h
index 47f25dd544..c1d57564e1 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUIBase.h
@@ -1,63 +1,63 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkBinaryThresholdToolGUIBase_h_Included
 #define QmitkBinaryThresholdToolGUIBase_h_Included
 
-#include "QmitkAutoSegmentationToolGUIBase.h"
+#include "QmitkSegWithPreviewToolGUIBase.h"
 #include "ctkRangeWidget.h"
 #include "ctkSliderWidget.h"
 
 #include <MitkSegmentationUIExports.h>
 
 /**
   \ingroup org_mitk_gui_qt_interactivesegmentation_internal
   \brief Base GUI for mitk::BinaryThresholdTool.
 
   This GUI shows a slider to change the tool's threshold and an OK button to accept a preview for actual thresholding.
 */
-class MITKSEGMENTATIONUI_EXPORT QmitkBinaryThresholdToolGUIBase : public QmitkAutoSegmentationToolGUIBase
+class MITKSEGMENTATIONUI_EXPORT QmitkBinaryThresholdToolGUIBase : public QmitkSegWithPreviewToolGUIBase
 {
   Q_OBJECT
 
 public:
-  mitkClassMacro(QmitkBinaryThresholdToolGUIBase, QmitkAutoSegmentationToolGUIBase);
+  mitkClassMacro(QmitkBinaryThresholdToolGUIBase, QmitkSegWithPreviewToolGUIBase);
 
   void OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat);
   void OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper);
 
 protected slots:
 
   void OnThresholdRangeChanged(double min, double max);
   void OnThresholdSliderChanged(double value);
 
 protected:
   QmitkBinaryThresholdToolGUIBase(bool ulMode);
   ~QmitkBinaryThresholdToolGUIBase() override;
 
-  void DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool) override;
-  void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool) override;
+  void DisconnectOldTool(mitk::SegWithPreviewTool* oldTool) override;
+  void ConnectNewTool(mitk::SegWithPreviewTool* newTool) override;
   void InitializeUI(QBoxLayout* mainLayout) override;
 
   void BusyStateChanged(bool) override;
 
   ctkRangeWidget* m_ThresholdRange = nullptr;
   ctkSliderWidget* m_ThresholdSlider = nullptr;
 
   /** Indicates if the tool UI is used for a tool with upper an lower threshold (true)
   ore only with one threshold (false)*/
   bool m_ULMode;
 
   bool m_InternalUpdate = false;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMaskStampWidget.cpp b/Modules/SegmentationUI/Qmitk/QmitkMaskStampWidget.cpp
index 5d72312905..2eca2226cd 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMaskStampWidget.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkMaskStampWidget.cpp
@@ -1,115 +1,115 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkMaskStampWidget.h"
 
 #include <mitkLabelSetImage.h>
 #include <mitkRenderingManager.h>
 #include <mitkToolManagerProvider.h>
 
 #include <QMessageBox>
 
 QmitkMaskStampWidget::QmitkMaskStampWidget(QWidget *parent, const char * /*name*/)
   : QWidget(parent), m_ToolManager(nullptr), m_DataStorage(nullptr)
 {
   m_Controls.setupUi(this);
   m_Controls.m_InformationWidget->hide();
 
-  m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
+  m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
   m_ToolManager->ActivateTool(-1);
 
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::NodePredicateProperty::Pointer isBinary =
     mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateAnd::Pointer isMask = mitk::NodePredicateAnd::New(isBinary, isImage);
 
   mitk::NodePredicateAnd::Pointer maskPredicate = mitk::NodePredicateAnd::New();
   maskPredicate->AddPredicate(isMask);
   maskPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
 
   m_Controls.m_cbMaskNodeSelector->SetPredicate(maskPredicate);
 
   connect(m_Controls.m_pbStamp, SIGNAL(clicked()), this, SLOT(OnStamp()));
   connect(m_Controls.m_cbShowInformation, SIGNAL(toggled(bool)), this, SLOT(OnShowInformation(bool)));
   m_Controls.m_InformationWidget->hide();
 }
 
 QmitkMaskStampWidget::~QmitkMaskStampWidget()
 {
 }
 
 void QmitkMaskStampWidget::SetDataStorage(mitk::DataStorage *storage)
 {
   m_DataStorage = storage;
   m_Controls.m_cbMaskNodeSelector->SetDataStorage(m_DataStorage);
 }
 
 void QmitkMaskStampWidget::OnStamp()
 {
   mitk::DataNode *maskNode = m_Controls.m_cbMaskNodeSelector->GetSelectedNode();
 
   if (!maskNode)
   {
     QMessageBox::information(this, "Mask Stamp", "Please load and select a mask before starting some action.");
     return;
   }
 
   mitk::Image *mask = dynamic_cast<mitk::Image *>(maskNode->GetData());
   if (!mask)
   {
     QMessageBox::information(this, "Mask Stamp", "Please load and select a mask before starting some action.");
     return;
   }
 
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
 
   if (!workingNode)
   {
     QMessageBox::information(this, "Mask Stamp", "Please load and select a segmentation before starting some action.");
     return;
   }
 
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
 
   if (!workingImage)
   {
     QMessageBox::information(this, "Mask Stamp", "Please load and select a segmentation before starting some action.");
     return;
   }
 
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   try
   {
     workingImage->MaskStamp(mask, m_Controls.m_chkOverwrite->isChecked());
   }
   catch (mitk::Exception &e)
   {
     QApplication::restoreOverrideCursor();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this, "Mask Stamp", "Could not stamp the selected mask.\n See error log for details.\n");
     return;
   }
 
   QApplication::restoreOverrideCursor();
 
   maskNode->SetVisibility(false);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkMaskStampWidget::OnShowInformation(bool on)
 {
   if (on)
     m_Controls.m_InformationWidget->show();
   else
     m_Controls.m_InformationWidget->hide();
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMaskStampWidget.h b/Modules/SegmentationUI/Qmitk/QmitkMaskStampWidget.h
index e75f8c8adf..456a6f1cc4 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMaskStampWidget.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkMaskStampWidget.h
@@ -1,61 +1,59 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkMaskStampWidget_h_Included
 #define QmitkMaskStampWidget_h_Included
 
 #include "MitkSegmentationUIExports.h"
 #include "mitkDataNode.h"
 
 #include <QWidget>
 
 #include "ui_QmitkMaskStampWidgetGUIControls.h"
 
 namespace mitk
 {
   class ToolManager;
 }
 
 /**
   \brief GUI for mask stamp functionality
 
-  This class uses the mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION context.
-
   \ingroup ToolManagerEtAl
   \ingroup Widgets
 */
 
 class MITKSEGMENTATIONUI_EXPORT QmitkMaskStampWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   QmitkMaskStampWidget(QWidget *parent = nullptr, const char *name = nullptr);
   ~QmitkMaskStampWidget() override;
 
   void SetDataStorage(mitk::DataStorage *storage);
 
 protected slots:
 
   void OnShowInformation(bool);
 
   void OnStamp();
 
 private:
   mitk::ToolManager *m_ToolManager;
 
   mitk::DataStorage *m_DataStorage;
 
   Ui::QmitkMaskStampWidgetGUIControls m_Controls;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelSegWithPreviewToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelSegWithPreviewToolGUIBase.cpp
new file mode 100644
index 0000000000..2ba34c9581
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelSegWithPreviewToolGUIBase.cpp
@@ -0,0 +1,149 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "QmitkMultiLabelSegWithPreviewToolGUIBase.h"
+#include "mitkSegWithPreviewTool.h"
+
+#include <QRadioButton>
+#include <QBoxLayout>
+
+QmitkMultiLabelSegWithPreviewToolGUIBase::QmitkMultiLabelSegWithPreviewToolGUIBase() : QmitkSegWithPreviewToolGUIBase(false)
+{
+  auto enableMLSelectedDelegate = [this](bool enabled)
+  {
+    auto tool = this->GetConnectedToolAs<mitk::SegWithPreviewTool>();
+    return nullptr != tool
+      ? (tool->GetLabelTransferMode() == mitk::SegWithPreviewTool::LabelTransferMode::AllLabels || !tool->GetSelectedLabels().empty()) && enabled
+      : false;
+  };
+
+  m_EnableConfirmSegBtnFnc = enableMLSelectedDelegate;
+}
+
+void QmitkMultiLabelSegWithPreviewToolGUIBase::InitializeUI(QBoxLayout* mainLayout)
+{
+  auto radioTransferAll = new QRadioButton("Transfer all labels", this);
+  radioTransferAll->setToolTip("Transfer all preview label when confirmed.");
+  radioTransferAll->setChecked(true);
+  connect(radioTransferAll, &QAbstractButton::toggled, this, &QmitkMultiLabelSegWithPreviewToolGUIBase::OnRadioTransferAllClicked);
+  mainLayout->addWidget(radioTransferAll);
+  m_RadioTransferAll = radioTransferAll;
+
+  auto radioTransferSelected = new QRadioButton("Transfer selected labels", this);
+  radioTransferSelected->setToolTip("Transfer the selected preview label when confirmed.");
+  radioTransferSelected->setChecked(false);
+  mainLayout->addWidget(radioTransferSelected);
+  m_RadioTransferSelected = radioTransferSelected;
+
+  m_LabelSelectionList = new QmitkSimpleLabelSetListWidget(this);
+  m_LabelSelectionList->setObjectName(QString::fromUtf8("m_LabelSelectionList"));
+  QSizePolicy sizePolicy2(QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
+  sizePolicy2.setHorizontalStretch(0);
+  sizePolicy2.setVerticalStretch(0);
+  sizePolicy2.setHeightForWidth(m_LabelSelectionList->sizePolicy().hasHeightForWidth());
+  m_LabelSelectionList->setSizePolicy(sizePolicy2);
+  m_LabelSelectionList->setMaximumSize(QSize(10000000, 10000000));
+  m_LabelSelectionList->setVisible(false);
+
+  mainLayout->addWidget(m_LabelSelectionList);
+  connect(m_LabelSelectionList, &QmitkSimpleLabelSetListWidget::SelectedLabelsChanged, this, &QmitkMultiLabelSegWithPreviewToolGUIBase::OnLabelSelectionChanged);
+
+  this->OnRadioTransferAllClicked(true);
+
+  Superclass::InitializeUI(mainLayout);
+}
+
+void QmitkMultiLabelSegWithPreviewToolGUIBase::OnLabelSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels)
+{
+  auto tool = this->GetConnectedToolAs<mitk::SegWithPreviewTool>();
+  if (nullptr != tool)
+  {
+    mitk::SegWithPreviewTool::SelectedLabelVectorType labelIDs;
+    for (const auto& label : selectedLabels)
+    {
+      labelIDs.push_back(label->GetValue());
+    }
+
+    tool->SetSelectedLabels(labelIDs);
+    this->ActualizePreviewLabelVisibility();
+    this->EnableWidgets(true); //used to actualize the ConfirmSeg btn via the delegate;
+  }
+}
+
+void QmitkMultiLabelSegWithPreviewToolGUIBase::ActualizePreviewLabelVisibility()
+{
+  auto tool = this->GetConnectedToolAs<mitk::SegWithPreviewTool>();
+  if (nullptr != tool)
+  {
+    auto preview = tool->GetPreviewSegmentation();
+    if (nullptr != preview)
+    {
+      auto labelSet = preview->GetActiveLabelSet();
+      auto selectedLabels = tool->GetSelectedLabels();
+
+      for (auto labelIter = labelSet->IteratorBegin(); labelIter != labelSet->IteratorEnd(); ++labelIter)
+      {
+        bool isVisible = tool->GetLabelTransferMode() == mitk::SegWithPreviewTool::LabelTransferMode::AllLabels
+          || (std::find(selectedLabels.begin(), selectedLabels.end(), labelIter->second->GetValue()) != selectedLabels.end());
+        labelIter->second->SetVisible(isVisible);
+        labelSet->UpdateLookupTable(labelIter->second->GetValue());
+      }
+    }
+    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+  }
+}
+
+void QmitkMultiLabelSegWithPreviewToolGUIBase::OnRadioTransferAllClicked(bool checked)
+{
+  m_LabelSelectionList->setVisible(!checked);
+
+  auto tool = this->GetConnectedToolAs<mitk::SegWithPreviewTool>();
+  if (nullptr != tool)
+  {
+    if (checked)
+    {
+      tool->SetLabelTransferMode(mitk::SegWithPreviewTool::LabelTransferMode::AllLabels);
+    }
+    else
+    {
+      tool->SetLabelTransferMode(mitk::SegWithPreviewTool::LabelTransferMode::SelectedLabels);
+    }
+  }
+  this->ActualizePreviewLabelVisibility();
+}
+
+void QmitkMultiLabelSegWithPreviewToolGUIBase::EnableWidgets(bool enabled)
+{
+  Superclass::EnableWidgets(enabled);
+  if (nullptr != m_LabelSelectionList)
+  {
+    m_LabelSelectionList->setEnabled(enabled);
+  }
+
+  if (nullptr != m_RadioTransferAll)
+  {
+    m_RadioTransferAll->setEnabled(enabled);
+  }
+
+  if (nullptr != m_RadioTransferSelected)
+  {
+    m_RadioTransferSelected->setEnabled(enabled);
+  }
+}
+
+void QmitkMultiLabelSegWithPreviewToolGUIBase::SetLabelSetPreview(const mitk::LabelSetImage* preview)
+{
+  if (nullptr != m_LabelSelectionList)
+  {
+    m_LabelSelectionList->SetLabelSetImage(preview);
+  }
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.h b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelSegWithPreviewToolGUIBase.h
similarity index 62%
rename from Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
rename to Modules/SegmentationUI/Qmitk/QmitkMultiLabelSegWithPreviewToolGUIBase.h
index e4e48dc867..d6d5caaeb9 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelSegWithPreviewToolGUIBase.h
@@ -1,52 +1,56 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
-#ifndef QmitkAutoMLSegmentationToolGUIBase_h_Included
-#define QmitkAutoMLSegmentationToolGUIBase_h_Included
+#ifndef QmitkMultiLabelSegWithPreviewToolGUIBase_h_Included
+#define QmitkMultiLabelSegWithPreviewToolGUIBase_h_Included
 
-#include "QmitkAutoSegmentationToolGUIBase.h"
+#include "QmitkSegWithPreviewToolGUIBase.h"
 
 #include "QmitkSimpleLabelSetListWidget.h"
 
 #include <MitkSegmentationUIExports.h>
 
 /**
   \ingroup org_mitk_gui_qt_interactivesegmentation_internal
   \brief GUI for tools based on mitk::AutoMLSegmentationWithPreviewTool.
 
   This GUI offers an additional list to select the label that should be confirmed.
 */
-class MITKSEGMENTATIONUI_EXPORT QmitkAutoMLSegmentationToolGUIBase : public QmitkAutoSegmentationToolGUIBase
+class MITKSEGMENTATIONUI_EXPORT QmitkMultiLabelSegWithPreviewToolGUIBase : public QmitkSegWithPreviewToolGUIBase
 {
   Q_OBJECT
 
 public:
-  mitkClassMacro(QmitkAutoMLSegmentationToolGUIBase, QmitkAutoSegmentationToolGUIBase);
+  mitkClassMacro(QmitkMultiLabelSegWithPreviewToolGUIBase, QmitkSegWithPreviewToolGUIBase);
 
 protected slots :
 
   void OnLabelSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels);
+  void OnRadioTransferAllClicked(bool checked);
 
 protected:
-  QmitkAutoMLSegmentationToolGUIBase();
-  ~QmitkAutoMLSegmentationToolGUIBase() = default;
+  QmitkMultiLabelSegWithPreviewToolGUIBase();
+  ~QmitkMultiLabelSegWithPreviewToolGUIBase() = default;
 
   void InitializeUI(QBoxLayout* mainLayout) override;
 
   void EnableWidgets(bool enabled) override;
   void SetLabelSetPreview(const mitk::LabelSetImage* preview);
+  void ActualizePreviewLabelVisibility();
 
 private:
   QmitkSimpleLabelSetListWidget* m_LabelSelectionList = nullptr;
+  QWidget* m_RadioTransferAll = nullptr;
+  QWidget* m_RadioTransferSelected = nullptr;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkNewSegmentationDialog.cpp b/Modules/SegmentationUI/Qmitk/QmitkNewSegmentationDialog.cpp
deleted file mode 100644
index a824e6d94a..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkNewSegmentationDialog.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include "QmitkNewSegmentationDialog.h"
-
-#include <itkRGBPixel.h>
-
-#include <QAbstractItemModel>
-#include <QColorDialog>
-#include <QStringListModel>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qlineedit.h>
-#include <qpushbutton.h>
-
-QmitkNewSegmentationDialog::QmitkNewSegmentationDialog(QWidget *parent)
-  : QDialog(parent) // true, modal
-  , selectedOrgan(tr("undefined"))
-  , newOrganEntry(false)
-{
-  QDialog::setFixedSize(250, 105);
-
-  QBoxLayout *verticalLayout = new QVBoxLayout(this);
-  verticalLayout->setMargin(5);
-  verticalLayout->setSpacing(5);
-
-  // to enter a name for the segmentation
-  lblPrompt = new QLabel(tr("Name and color of the segmentation"), this);
-  verticalLayout->addWidget(lblPrompt);
-
-  // to choose a color
-  m_Color.setRed(255);
-  m_Color.setGreen(0);
-  m_Color.setBlue(0);
-
-  btnColor = new QPushButton("", this);
-  btnColor->setFixedWidth(25);
-  btnColor->setAutoFillBackground(true);
-  btnColor->setStyleSheet(QString("background-color:rgb(%1, %2, %3)").arg(m_Color.red()).arg(m_Color.green()).arg(m_Color.blue()));
-
-  connect(btnColor, SIGNAL(clicked()), this, SLOT(onColorBtnClicked()));
-
-  lineEditName = new QLineEdit("", this);
-  QStringList completionList;
-  completionList << "";
-  completer = new QCompleter(completionList);
-  completer->setCaseSensitivity(Qt::CaseInsensitive);
-  lineEditName->setCompleter(completer);
-
-  connect(completer, SIGNAL(activated(const QString &)), this, SLOT(onColorChange(const QString &)));
-
-  QBoxLayout *horizontalLayout2 = new QHBoxLayout();
-  verticalLayout->addLayout(horizontalLayout2);
-  horizontalLayout2->addWidget(btnColor);
-  horizontalLayout2->addWidget(lineEditName);
-
-  // buttons for closing the dialog
-  btnOk = new QPushButton(tr("Ok"), this);
-  btnOk->setDefault(true);
-  connect(btnOk, SIGNAL(clicked()), this, SLOT(onAcceptClicked()));
-
-  QPushButton *btnCancel = new QPushButton(tr("Cancel"), this);
-  connect(btnCancel, SIGNAL(clicked()), this, SLOT(reject()));
-
-  QBoxLayout *horizontalLayout = new QHBoxLayout();
-  verticalLayout->addLayout(horizontalLayout);
-  horizontalLayout->setSpacing(5);
-  horizontalLayout->addStretch();
-  horizontalLayout->addWidget(btnOk);
-  horizontalLayout->addWidget(btnCancel);
-
-  lineEditName->setFocus();
-}
-
-QmitkNewSegmentationDialog::~QmitkNewSegmentationDialog()
-{
-}
-
-const QString QmitkNewSegmentationDialog::GetSegmentationName()
-{
-  return m_SegmentationName;
-}
-
-mitk::Color QmitkNewSegmentationDialog::GetColor()
-{
-  mitk::Color colorProperty;
-  if (m_Color.isValid())
-  {
-    colorProperty.SetRed(m_Color.redF());
-    colorProperty.SetGreen(m_Color.greenF());
-    colorProperty.SetBlue(m_Color.blueF());
-  }
-  else
-  {
-    colorProperty.SetRed(1);
-    colorProperty.SetGreen(0);
-    colorProperty.SetBlue(0);
-  }
-  return colorProperty;
-}
-
-const char *QmitkNewSegmentationDialog::GetOrganType()
-{
-  return selectedOrgan.toLocal8Bit().constData();
-}
-
-void QmitkNewSegmentationDialog::SetSegmentationName(const QString &segmentationName)
-{
-  lineEditName->setText(segmentationName);
-}
-
-void QmitkNewSegmentationDialog::SetColor(const mitk::Color &color)
-{
-  m_Color.setRedF(color.GetRed());
-  m_Color.setGreenF(color.GetGreen());
-  m_Color.setBlueF(color.GetBlue());
-
-  btnColor->setStyleSheet(QString("background-color:rgb(%1, %2, %3)").arg(m_Color.red()).arg(m_Color.green()).arg(m_Color.blue()));
-}
-
-void QmitkNewSegmentationDialog::SetSuggestionList(QStringList organColorList)
-{
-  QStringList::iterator iter;
-  for (iter = organColorList.begin(); iter != organColorList.end(); ++iter)
-  {
-    QString &element = *iter;
-    QString colorName = element.right(7);
-    QColor color(colorName);
-    QString organName = element.left(element.size() - 7);
-
-    organList.push_back(organName);
-    colorList.push_back(color);
-  }
-
-  QStringListModel *completeModel = static_cast<QStringListModel *>(completer->model());
-  completeModel->setStringList(organList);
-}
-
-void QmitkNewSegmentationDialog::setPrompt(const QString &prompt)
-{
-  lblPrompt->setText(prompt);
-}
-
-void QmitkNewSegmentationDialog::onAcceptClicked()
-{
-  m_SegmentationName = lineEditName->text();
-  accept();
-}
-
-void QmitkNewSegmentationDialog::onNewOrganNameChanged(const QString &newText)
-{
-  if (!newText.isEmpty())
-  {
-    btnOk->setEnabled(true);
-  }
-
-  selectedOrgan = newText;
-  SetSegmentationName(newText);
-}
-
-void QmitkNewSegmentationDialog::onColorBtnClicked()
-{
-  auto selectedColor = QColorDialog::getColor(m_Color);
-  if (selectedColor.isValid())
-  {
-    m_Color = selectedColor;
-    btnColor->setStyleSheet(QString("background-color:rgb(%1, %2, %3)").arg(m_Color.red()).arg(m_Color.green()).arg(m_Color.blue()));
-  }
-}
-
-void QmitkNewSegmentationDialog::onColorChange(const QString &completedWord)
-{
-  if (organList.contains(completedWord))
-  {
-    int j = organList.indexOf(completedWord);
-    m_Color = colorList.at(j);
-    btnColor->setStyleSheet(QString("background-color:rgb(%1, %2, %3)").arg(m_Color.red()).arg(m_Color.green()).arg(m_Color.blue()));
-  }
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkNewSegmentationDialog.h b/Modules/SegmentationUI/Qmitk/QmitkNewSegmentationDialog.h
deleted file mode 100644
index e8559ebd77..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkNewSegmentationDialog.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#ifndef QmitkNewSegmentationDialog_h_Included
-#define QmitkNewSegmentationDialog_h_Included
-
-#include "mitkColorProperty.h"
-#include <MitkSegmentationUIExports.h>
-
-#include <qdialog.h>
-
-#include <QCompleter>
-
-class QLabel;
-class QLineEdit;
-class Q3ListBox;
-class QPushButton;
-
-#include <mitkCommon.h>
-
-/**
-  \brief Dialog for QmitkInteractiveSegmentation.
-
-  \ingroup ToolManagerEtAl
-  \ingroup Widgets
-
-  This dialog is used to ask a user about the type of a newly created segmentation and a name for it.
-*/
-class MITKSEGMENTATIONUI_EXPORT QmitkNewSegmentationDialog : public QDialog
-{
-  Q_OBJECT
-
-public:
-  QmitkNewSegmentationDialog(QWidget *parent = nullptr);
-
-  ~QmitkNewSegmentationDialog() override;
-
-  const QString GetSegmentationName();
-  mitk::Color GetColor();
-  const char *GetOrganType();
-
-  void SetSegmentationName(const QString &segmentationName);
-  void SetColor(const mitk::Color &color);
-  void SetSuggestionList(QStringList organColorList);
-
-signals:
-
-public slots:
-
-  void setPrompt(const QString &prompt);
-
-protected slots:
-
-  void onAcceptClicked();
-  void onNewOrganNameChanged(const QString &);
-  void onColorBtnClicked();
-  void onColorChange(const QString &completedWord);
-
-protected:
-
-  QLabel *lblPrompt;
-  Q3ListBox *lstOrgans;
-  QLineEdit *lineEditName;
-
-  QPushButton *btnColor;
-  QPushButton *btnOk;
-
-  QLineEdit *edtNewOrgan;
-
-  QString selectedOrgan;
-
-  bool newOrganEntry;
-
-  QColor m_Color;
-
-  QCompleter *completer;
-
-  QString m_SegmentationName;
-
-  QStringList organList;
-  QList<QColor> colorList;
-};
-
-#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.cpp
index 6533d2e726..e199373c53 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.cpp
@@ -1,129 +1,143 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkOtsuTool3DGUI.h"
 #include "mitkOtsuTool3D.h"
 
 #include <QMessageBox>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkOtsuTool3DGUI, "")
 
-QmitkOtsuTool3DGUI::QmitkOtsuTool3DGUI() : QmitkAutoMLSegmentationToolGUIBase()
+QmitkOtsuTool3DGUI::QmitkOtsuTool3DGUI() : QmitkMultiLabelSegWithPreviewToolGUIBase(), m_SuperclassEnableConfirmSegBtnFnc(m_EnableConfirmSegBtnFnc)
 {
+  auto enableMLSelectedDelegate = [this](bool enabled)
+  {
+    if (this->m_FirstPreviewComputation)
+    {
+      return false;
+    }
+    else
+    {
+      return this->m_SuperclassEnableConfirmSegBtnFnc(enabled);
+    }
+  };
+
+  m_EnableConfirmSegBtnFnc = enableMLSelectedDelegate;
 }
 
-void QmitkOtsuTool3DGUI::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
+void QmitkOtsuTool3DGUI::ConnectNewTool(mitk::SegWithPreviewTool* newTool)
 {
   Superclass::ConnectNewTool(newTool);
 
   newTool->IsTimePointChangeAwareOff();
   m_FirstPreviewComputation = true;
 }
 
 void QmitkOtsuTool3DGUI::InitializeUI(QBoxLayout* mainLayout)
 {
   m_Controls.setupUi(this);
   mainLayout->addLayout(m_Controls.verticalLayout);
 
   connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnPreviewBtnClicked()));
   connect(m_Controls.m_Spinbox, SIGNAL(valueChanged(int)), this, SLOT(OnRegionSpinboxChanged(int)));
   connect(m_Controls.advancedSettingsButton, SIGNAL(toggled(bool)), this, SLOT(OnAdvancedSettingsButtonToggled(bool)));
 
   this->OnAdvancedSettingsButtonToggled(false);
 
   Superclass::InitializeUI(mainLayout);
 }
 
 void QmitkOtsuTool3DGUI::OnRegionSpinboxChanged(int numberOfRegions)
 {
   // we have to change to minimum number of histogram bins accordingly
   int curBinValue = m_Controls.m_BinsSpinBox->value();
   if (curBinValue < numberOfRegions)
     m_Controls.m_BinsSpinBox->setValue(numberOfRegions);
 }
 
 void QmitkOtsuTool3DGUI::OnAdvancedSettingsButtonToggled(bool toggled)
 {
   m_Controls.m_ValleyCheckbox->setVisible(toggled);
   m_Controls.binLabel->setVisible(toggled);
   m_Controls.m_BinsSpinBox->setVisible(toggled);
 
   auto tool = this->GetConnectedToolAs<mitk::OtsuTool3D>();
   if (toggled && nullptr != tool)
   {
     int max = tool->GetMaxNumberOfBins();
     if (max >= m_Controls.m_BinsSpinBox->minimum())
     {
       m_Controls.m_BinsSpinBox->setMaximum(max);
     }
   }
 }
 
 void QmitkOtsuTool3DGUI::OnPreviewBtnClicked()
 {
   auto tool = this->GetConnectedToolAs<mitk::OtsuTool3D>();
   if (nullptr != tool)
   {
     if (!m_FirstPreviewComputation &&
       (tool->GetNumberOfRegions() == static_cast<unsigned int>(m_Controls.m_Spinbox->value()) &&
       tool->GetUseValley() == m_Controls.m_ValleyCheckbox->isChecked() &&
       tool->GetNumberOfBins() == static_cast<unsigned int>(m_Controls.m_BinsSpinBox->value())))
       return;
 
     m_FirstPreviewComputation = false;
 
     try
     {
       int proceed;
       QMessageBox *messageBox = new QMessageBox(QMessageBox::Question,
                                                 nullptr,
                                                 "The otsu segmentation computation may take several minutes depending "
                                                 "on the number of Regions you selected. Proceed anyway?",
                                                 QMessageBox::Ok | QMessageBox::Cancel);
       if (m_Controls.m_Spinbox->value() >= 5)
       {
         proceed = messageBox->exec();
         if (proceed != QMessageBox::Ok)
           return;
       }
 
       tool->SetNumberOfRegions(static_cast<unsigned int>(m_Controls.m_Spinbox->value()));
       tool->SetUseValley(m_Controls.m_ValleyCheckbox->isChecked());
       tool->SetNumberOfBins(static_cast<unsigned int>(m_Controls.m_BinsSpinBox->value()));
 
       tool->UpdatePreview();
     }
     catch (...)
     {
       this->setCursor(Qt::ArrowCursor);
       QMessageBox *messageBox =
         new QMessageBox(QMessageBox::Critical,
                         nullptr,
                         "itkOtsuFilter error: image dimension must be in {2, 3} and no RGB images can be handled.");
       messageBox->exec();
       delete messageBox;
       return;
     }
 
-    this->SetLabelSetPreview(tool->GetMLPreview());
+    this->SetLabelSetPreview(tool->GetPreviewSegmentation());
     tool->IsTimePointChangeAwareOn();
+    this->ActualizePreviewLabelVisibility();
   }
 }
 
 void QmitkOtsuTool3DGUI::EnableWidgets(bool enabled)
 {
   Superclass::EnableWidgets(enabled);
   m_Controls.m_ValleyCheckbox->setEnabled(enabled);
   m_Controls.binLabel->setEnabled(enabled);
   m_Controls.m_BinsSpinBox->setEnabled(enabled);
   m_Controls.previewButton->setEnabled(enabled);
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h b/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h
index 55b7030ea5..44078f4d61 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h
@@ -1,64 +1,65 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkOtsuTool3DGUI_h_Included
 #define QmitkOtsuTool3DGUI_h_Included
 
-#include "QmitkAutoMLSegmentationToolGUIBase.h"
+#include "QmitkMultiLabelSegWithPreviewToolGUIBase.h"
 
 #include "ui_QmitkOtsuToolWidgetControls.h"
 
 #include <MitkSegmentationUIExports.h>
 
 /**
   \ingroup org_mitk_gui_qt_interactivesegmentation_internal
   \brief GUI for mitk::OtsuTool3D.
   \sa mitk::
 
   This GUI shows ...
 
   Last contributor: $Author$
 */
-class MITKSEGMENTATIONUI_EXPORT QmitkOtsuTool3DGUI : public QmitkAutoMLSegmentationToolGUIBase
+class MITKSEGMENTATIONUI_EXPORT QmitkOtsuTool3DGUI : public QmitkMultiLabelSegWithPreviewToolGUIBase
 {
   Q_OBJECT
 
 public:
-  mitkClassMacro(QmitkOtsuTool3DGUI, QmitkAutoMLSegmentationToolGUIBase);
+  mitkClassMacro(QmitkOtsuTool3DGUI, QmitkMultiLabelSegWithPreviewToolGUIBase);
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
 protected slots :
 
   void OnPreviewBtnClicked();
 
   void OnRegionSpinboxChanged(int);
 
 private slots:
 
   void OnAdvancedSettingsButtonToggled(bool toggled);
 
 protected:
   QmitkOtsuTool3DGUI();
   ~QmitkOtsuTool3DGUI() = default;
 
-  void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool) override;
+  void ConnectNewTool(mitk::SegWithPreviewTool* newTool) override;
   void InitializeUI(QBoxLayout* mainLayout) override;
 
   void EnableWidgets(bool enabled) override;
 
   Ui_QmitkOtsuToolWidgetControls m_Controls;
 
   bool m_FirstPreviewComputation = true;
+  EnableConfirmSegBtnFunctionType m_SuperclassEnableConfirmSegBtnFnc;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.cpp
index a54812842d..35d0b0176b 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.cpp
@@ -1,74 +1,111 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkPickingToolGUI.h"
 
 #include <mitkPickingTool.h>
-#include <qlabel.h>
-#include <qpushbutton.h>
-#include <qboxlayout.h>
+#include <QLabel>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QBoxLayout>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkPickingToolGUI, "")
 
-QmitkPickingToolGUI::QmitkPickingToolGUI() : QmitkAutoSegmentationToolGUIBase(false)
+QmitkPickingToolGUI::QmitkPickingToolGUI() : QmitkSegWithPreviewToolGUIBase(false)
 {
   auto enablePickingDelegate = [this](bool enabled)
   {
     bool result = false;
     auto tool = this->GetConnectedToolAs<mitk::PickingTool>();
     if (nullptr != tool)
     {
       result = enabled && tool->HasPicks();
     }
 
     return result;
   };
 
   m_EnableConfirmSegBtnFnc = enablePickingDelegate;
 }
 
 QmitkPickingToolGUI::~QmitkPickingToolGUI()
 {
 }
 
 void QmitkPickingToolGUI::OnResetPicksClicked()
 {
   auto tool = this->GetConnectedToolAs<mitk::PickingTool>();
   if (nullptr != tool)
   {
     tool->ClearPicks();
   }
 }
 
+void QmitkPickingToolGUI::OnRadioPickClicked(bool checked)
+{
+  if (checked)
+  {
+    this->SetMergeStyle(mitk::MultiLabelSegmentation::MergeStyle::Replace);
+    this->SetOverwriteStyle(mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks);
+  }
+  else
+  {
+    this->SetMergeStyle(mitk::MultiLabelSegmentation::MergeStyle::Merge);
+    this->SetOverwriteStyle(mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
+  }
+}
+
 void QmitkPickingToolGUI::InitializeUI(QBoxLayout* mainLayout)
 {
+  auto radioPick = new QRadioButton("Picking mode", this);
+  radioPick->setToolTip("Pick certain parts of the label and dismiss the rest of the label content");
+  radioPick->setChecked(true);
+  connect(radioPick, &QAbstractButton::toggled, this, &QmitkPickingToolGUI::OnRadioPickClicked);
+  mainLayout->addWidget(radioPick);
+  m_RadioPick = radioPick;
+  this->OnRadioPickClicked(true);
+
+  auto radioRelabel = new QRadioButton("Relabel mode", this);
+  radioRelabel->setToolTip("Relabel certain parts of the segmentation as active label.");
+  radioRelabel->setChecked(false);
+  mainLayout->addWidget(radioRelabel);
+  m_RadioRelabel = radioRelabel;
+
   QLabel* label = new QLabel("Press SHIFT and click to pick region(s).\nPress DEL to remove last pick.", this);
   mainLayout->addWidget(label);
 
   auto clearButton = new QPushButton("Reset picks",this);
   connect(clearButton, &QPushButton::clicked, this, &QmitkPickingToolGUI::OnResetPicksClicked);
   mainLayout->addWidget(clearButton);
   m_ClearPicksBtn = clearButton;
 
   Superclass::InitializeUI(mainLayout);
 }
 
 void QmitkPickingToolGUI::EnableWidgets(bool enabled)
 {
   Superclass::EnableWidgets(enabled);
 
   if (nullptr != m_ClearPicksBtn)
   {
     m_ClearPicksBtn->setEnabled(enabled);
   }
+  if (nullptr != m_RadioPick)
+  {
+    m_RadioPick->setEnabled(enabled);
+  }
+  if (nullptr != m_RadioRelabel)
+  {
+    m_RadioRelabel->setEnabled(enabled);
+  }
 }
 
diff --git a/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.h
index 0a1c65aecb..46c99cc6ad 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.h
@@ -1,47 +1,50 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkPickingToolGUI_h_Included
 #define QmitkPickingToolGUI_h_Included
 
-#include "QmitkAutoSegmentationToolGUIBase.h"
+#include "QmitkSegWithPreviewToolGUIBase.h"
 #include <MitkSegmentationUIExports.h>
 
 /**
 \ingroup org_mitk_gui_qt_interactivesegmentation_internal
 \brief GUI for mitk::PickingTool.
 \sa mitk::PickingTool
 */
-class MITKSEGMENTATIONUI_EXPORT QmitkPickingToolGUI : public QmitkAutoSegmentationToolGUIBase
+class MITKSEGMENTATIONUI_EXPORT QmitkPickingToolGUI : public QmitkSegWithPreviewToolGUIBase
 {
   Q_OBJECT
 
 public:
-  mitkClassMacro(QmitkPickingToolGUI, QmitkAutoSegmentationToolGUIBase);
+  mitkClassMacro(QmitkPickingToolGUI, QmitkSegWithPreviewToolGUIBase);
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
 protected slots :
   void OnResetPicksClicked();
+  void OnRadioPickClicked(bool checked);
 
 protected:
   QmitkPickingToolGUI();
   ~QmitkPickingToolGUI() override;
 
   void InitializeUI(QBoxLayout* mainLayout) override;
   void EnableWidgets(bool enabled) override;
 
 private:
   QWidget* m_ClearPicksBtn = nullptr;
+  QWidget* m_RadioPick = nullptr;
+  QWidget* m_RadioRelabel = nullptr;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSegWithPreviewToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkSegWithPreviewToolGUIBase.cpp
new file mode 100644
index 0000000000..03b8b4851f
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkSegWithPreviewToolGUIBase.cpp
@@ -0,0 +1,186 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "QmitkSegWithPreviewToolGUIBase.h"
+
+#include <qcheckbox.h>
+#include <qpushbutton.h>
+#include <qboxlayout.h>
+#include <qlabel.h>
+#include <QApplication>
+
+bool DefaultEnableConfirmSegBtnFunction(bool enabled)
+{
+  return enabled;
+}
+
+QmitkSegWithPreviewToolGUIBase::QmitkSegWithPreviewToolGUIBase(bool mode2D) : QmitkToolGUI(), m_EnableConfirmSegBtnFnc(DefaultEnableConfirmSegBtnFunction), m_Mode2D(mode2D)
+{
+  connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
+}
+
+QmitkSegWithPreviewToolGUIBase::~QmitkSegWithPreviewToolGUIBase()
+{
+  if (m_Tool.IsNotNull())
+  {
+    m_Tool->CurrentlyBusy -= mitk::MessageDelegate1<QmitkSegWithPreviewToolGUIBase, bool>(this, &QmitkSegWithPreviewToolGUIBase::BusyStateChanged);
+  }
+}
+
+void QmitkSegWithPreviewToolGUIBase::OnNewToolAssociated(mitk::Tool *tool)
+{
+  if (m_Tool.IsNotNull())
+  {
+    this->DisconnectOldTool(m_Tool);
+  }
+
+  m_Tool = dynamic_cast<mitk::SegWithPreviewTool*>(tool);
+
+  if (nullptr == m_MainLayout)
+  {
+    // create the visible widgets
+    m_MainLayout = new QVBoxLayout(this);
+    m_ConfirmSegBtn = new QPushButton("Confirm Segmentation", this);
+    connect(m_ConfirmSegBtn, SIGNAL(clicked()), this, SLOT(OnAcceptPreview()));
+
+    m_CheckIgnoreLocks = new QCheckBox("Ignore label locks", this);
+    m_CheckIgnoreLocks->setChecked(m_Tool->GetOverwriteStyle() == mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
+    m_CheckIgnoreLocks->setToolTip("If checked, the lock state of labels will be ignored when the preview segmentation is confermed. Thus also locked label pixels can be changed by the operation.");
+
+    m_CheckMerge = new QCheckBox("Merge with existing content", this);
+    m_CheckMerge->setChecked(m_Tool->GetMergeStyle()==mitk::MultiLabelSegmentation::MergeStyle::Merge);
+    m_CheckMerge->setToolTip("If checked, the preview segmantation will be merged with the existing segmantation into a union. If unchecked, the preview content will replace the old segmantation");
+
+    m_CheckProcessAll = new QCheckBox("Process all time steps", this);
+    m_CheckProcessAll->setChecked(false);
+    m_CheckProcessAll->setToolTip("Process all time steps of the dynamic segmentation and not just the currently visible time step.");
+    m_CheckProcessAll->setVisible(!m_Mode2D);
+    //remark: keept m_CheckProcessAll deactivated in 2D because in this refactoring
+    //it should be kept to the status quo and it was not clear how interpolation
+    //would behave. As soon as it is sorted out we can remove that "feature switch"
+    //or the comment.
+
+    this->InitializeUI(m_MainLayout);
+
+    m_MainLayout->addWidget(m_ConfirmSegBtn);
+    m_MainLayout->addWidget(m_CheckIgnoreLocks);
+    m_MainLayout->addWidget(m_CheckMerge);
+    m_MainLayout->addWidget(m_CheckProcessAll);
+  }
+
+  if (m_Tool.IsNotNull())
+  {
+    this->ConnectNewTool(m_Tool);
+  }
+}
+
+void QmitkSegWithPreviewToolGUIBase::OnAcceptPreview()
+{
+  if (m_Tool.IsNotNull())
+  {
+    if (m_CheckIgnoreLocks->isChecked())
+    {
+      m_Tool->SetOverwriteStyle(mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
+    }
+    else
+    {
+      m_Tool->SetOverwriteStyle(mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks);
+    }
+
+    if (m_CheckMerge->isChecked())
+    {
+      m_Tool->SetMergeStyle(mitk::MultiLabelSegmentation::MergeStyle::Merge);
+    }
+    else
+    {
+      m_Tool->SetMergeStyle(mitk::MultiLabelSegmentation::MergeStyle::Replace);
+    }
+
+    m_Tool->SetCreateAllTimeSteps(m_CheckProcessAll->isChecked());
+
+    m_ConfirmSegBtn->setEnabled(false);
+    m_Tool->ConfirmSegmentation();
+  }
+}
+
+void QmitkSegWithPreviewToolGUIBase::DisconnectOldTool(mitk::SegWithPreviewTool* oldTool)
+{
+  oldTool->CurrentlyBusy -= mitk::MessageDelegate1<QmitkSegWithPreviewToolGUIBase, bool>(this, &QmitkSegWithPreviewToolGUIBase::BusyStateChanged);
+}
+
+void QmitkSegWithPreviewToolGUIBase::ConnectNewTool(mitk::SegWithPreviewTool* newTool)
+{
+  newTool->CurrentlyBusy +=
+    mitk::MessageDelegate1<QmitkSegWithPreviewToolGUIBase, bool>(this, &QmitkSegWithPreviewToolGUIBase::BusyStateChanged);
+
+  m_CheckProcessAll->setVisible(newTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps() > 1);
+
+  this->EnableWidgets(true);
+}
+
+void QmitkSegWithPreviewToolGUIBase::InitializeUI(QBoxLayout* /*mainLayout*/)
+{
+  //default implementation does nothing
+}
+
+void QmitkSegWithPreviewToolGUIBase::BusyStateChanged(bool isBusy)
+{
+  if (isBusy)
+  {
+    QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
+  }
+  else
+  {
+    QApplication::restoreOverrideCursor();
+  }
+  this->EnableWidgets(!isBusy);
+ }
+
+void QmitkSegWithPreviewToolGUIBase::EnableWidgets(bool enabled)
+{
+  if (nullptr != m_MainLayout)
+  {
+    if (nullptr != m_ConfirmSegBtn)
+    {
+      m_ConfirmSegBtn->setEnabled(m_EnableConfirmSegBtnFnc(enabled));
+    }
+    if (nullptr != m_CheckIgnoreLocks)
+    {
+      m_CheckIgnoreLocks->setEnabled(enabled);
+    }
+    if (nullptr != m_CheckMerge)
+    {
+      m_CheckMerge->setEnabled(enabled);
+    }
+    if (nullptr != m_CheckProcessAll)
+    {
+      m_CheckProcessAll->setEnabled(enabled);
+    }
+  }
+}
+
+void QmitkSegWithPreviewToolGUIBase::SetMergeStyle(mitk::MultiLabelSegmentation::MergeStyle mergeStyle)
+{
+  if (nullptr != m_CheckMerge)
+  {
+    m_CheckMerge->setChecked(mergeStyle == mitk::MultiLabelSegmentation::MergeStyle::Merge);
+  }
+};
+
+void QmitkSegWithPreviewToolGUIBase::SetOverwriteStyle(mitk::MultiLabelSegmentation::OverwriteStyle overwriteStyle)
+{
+  if (nullptr != m_CheckIgnoreLocks)
+  {
+    m_CheckIgnoreLocks->setChecked(overwriteStyle == mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
+  }
+};
+
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.h b/Modules/SegmentationUI/Qmitk/QmitkSegWithPreviewToolGUIBase.h
similarity index 73%
rename from Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.h
rename to Modules/SegmentationUI/Qmitk/QmitkSegWithPreviewToolGUIBase.h
index 2c6eddf881..6f5f0bedee 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkSegWithPreviewToolGUIBase.h
@@ -1,93 +1,95 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
-#ifndef QmitkAutoSegmentationToolGUIBase_h_Included
-#define QmitkAutoSegmentationToolGUIBase_h_Included
+#ifndef QmitkSegWithPreviewToolGUIBase_h_Included
+#define QmitkSegWithPreviewToolGUIBase_h_Included
 
 #include "QmitkToolGUI.h"
 
-#include "mitkAutoSegmentationWithPreviewTool.h"
+#include "mitkSegWithPreviewTool.h"
 
 #include <MitkSegmentationUIExports.h>
 
 class QCheckBox;
 class QPushButton;
 class QBoxLayout;
 
 /**
   \ingroup org_mitk_gui_qt_interactivesegmentation_internal
   \brief GUI base clase for tools derived from mitk::AutoSegmentationTool.
 */
-class MITKSEGMENTATIONUI_EXPORT QmitkAutoSegmentationToolGUIBase : public QmitkToolGUI
+class MITKSEGMENTATIONUI_EXPORT QmitkSegWithPreviewToolGUIBase : public QmitkToolGUI
 {
   Q_OBJECT
 
 public:
-  mitkClassMacro(QmitkAutoSegmentationToolGUIBase, QmitkToolGUI);
+  mitkClassMacro(QmitkSegWithPreviewToolGUIBase, QmitkToolGUI);
   itkCloneMacro(Self);
 
   itkGetConstMacro(Mode2D, bool);
 
 protected slots:
 
   void OnNewToolAssociated(mitk::Tool *);
 
   void OnAcceptPreview();
 
 protected:
-  QmitkAutoSegmentationToolGUIBase(bool mode2D);
-  ~QmitkAutoSegmentationToolGUIBase() override;
+  QmitkSegWithPreviewToolGUIBase(bool mode2D);
+  ~QmitkSegWithPreviewToolGUIBase() override;
 
-  virtual void DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool);
-  virtual void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool);
+  virtual void DisconnectOldTool(mitk::SegWithPreviewTool* oldTool);
+  virtual void ConnectNewTool(mitk::SegWithPreviewTool* newTool);
 
   /**This method is called by OnNewToolAssociated if the UI is initialized the
    first time to allow derived classes to introduce own UI code. Overwrite to change.
    The implementation should ensure that alle widgets needed for the tool UI are
    properly allocated. If one needs to eecute time (e.g. to connect events between the tool
    and the UI) each time the tool changes, override the functions ConnectNewTool() and
    DisconnectOldTool().*/
   virtual void InitializeUI(QBoxLayout* mainLayout);
 
   void BusyStateChanged(bool isBusy) override;
 
   using EnableConfirmSegBtnFunctionType = std::function<bool(bool)>;
   EnableConfirmSegBtnFunctionType m_EnableConfirmSegBtnFnc;
 
   /**This method is used to control/set the enabled state of the tool UI
     widgets. It is e.g. used if the busy state is changed (see BusyStateChanged).
     Override the default implmentation, e.g. if a tool adds his own UI elements
     (normally by overriding InitializeUI()) and wants to control how the widgets
     are enabled/disabled.*/
   virtual void EnableWidgets(bool enabled);
 
   template <class TTool>
   TTool* GetConnectedToolAs()
   {
     return dynamic_cast<TTool*>(m_Tool.GetPointer());
   };
 
-
+  void SetMergeStyle(mitk::MultiLabelSegmentation::MergeStyle mergeStyle);
+  void SetOverwriteStyle(mitk::MultiLabelSegmentation::OverwriteStyle overwriteStyle);
 
 private:
+  QCheckBox* m_CheckIgnoreLocks = nullptr;
+  QCheckBox* m_CheckMerge = nullptr;
   QCheckBox* m_CheckProcessAll = nullptr;
-  QCheckBox* m_CheckCreateNew = nullptr;
   QPushButton* m_ConfirmSegBtn = nullptr;
   QBoxLayout* m_MainLayout = nullptr;
 
   /**Indicates if the tool is in 2D or 3D mode.*/
   bool m_Mode2D;
 
-  mitk::AutoSegmentationWithPreviewTool::Pointer m_Tool;
+  mitk::SegWithPreviewTool::Pointer m_Tool;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSegmentationOrganNamesHandling.cpp b/Modules/SegmentationUI/Qmitk/QmitkSegmentationOrganNamesHandling.cpp
deleted file mode 100644
index c027481f2b..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkSegmentationOrganNamesHandling.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include <QStringList>
-#include <mitkAnatomicalStructureColorPresets.h>
-#include <vtkSmartPointer.h>
-
-namespace mitk
-{
-  struct OrganNamesHandling
-  {
-    static QStringList GetDefaultOrganColorString()
-    {
-      QStringList organColors;
-
-      auto presets = vtkSmartPointer<AnatomicalStructureColorPresets>::New();
-      presets->LoadPreset();
-
-      for (const auto& preset : presets->GetColorPresets())
-      {
-        auto organName = preset.first.c_str();
-        auto color = QColor(preset.second.GetRed(), preset.second.GetGreen(), preset.second.GetBlue());
-
-        AppendToOrganList(organColors, organName, color);
-      }
-      return organColors;
-    }
-
-    static void UpdateOrganList(QStringList& organColors, const QString& organname, mitk::Color color)
-    {
-      QString listElement(organname + QColor(color.GetRed() * 255, color.GetGreen() * 255, color.GetBlue() * 255).name());
-
-      // remove previous definition if necessary
-      int oldIndex = organColors.indexOf(QRegExp(QRegExp::escape(organname) + "#......", Qt::CaseInsensitive));
-      if (oldIndex < 0 || organColors.at(oldIndex) != listElement)
-      {
-        if (oldIndex >= 0)
-        {
-          organColors.removeAt(oldIndex);
-        }
-
-        // add colored organ name AND sort list
-        organColors.append(listElement);
-        organColors.sort();
-      }
-    }
-
-    static void AppendToOrganList(QStringList& organColors, const QString& organname, const QColor& color)
-    {
-      organColors.append(organname + color.name());
-    }
-  };
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSimpleLabelSetListWidget.cpp b/Modules/SegmentationUI/Qmitk/QmitkSimpleLabelSetListWidget.cpp
index 8d6f3215f9..e0be0aa079 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSimpleLabelSetListWidget.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSimpleLabelSetListWidget.cpp
@@ -1,182 +1,199 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkSimpleLabelSetListWidget.h"
 
 #include "mitkMessage.h"
 
 #include <qlayout.h>
 
-QmitkSimpleLabelSetListWidget::QmitkSimpleLabelSetListWidget(QWidget* parent) : QWidget(parent), m_LabelList(nullptr)
+QmitkSimpleLabelSetListWidget::QmitkSimpleLabelSetListWidget(QWidget* parent) : QWidget(parent), m_LabelList(nullptr), m_Emmiting(false)
 {
   QGridLayout* layout = new QGridLayout(this);
   this->setContentsMargins(0, 0, 0, 0);
 
   m_LabelList = new QListWidget(this);
   m_LabelList->setSelectionMode(QAbstractItemView::MultiSelection);
   m_LabelList->setResizeMode(QListView::Adjust);
   m_LabelList->setAutoScrollMargin(0);
   layout->addWidget(m_LabelList);
 
   connect(m_LabelList, SIGNAL(itemSelectionChanged()), this, SLOT(OnLabelSelectionChanged()));
 }
 
 QmitkSimpleLabelSetListWidget::~QmitkSimpleLabelSetListWidget()
 {
   if (m_LabelSetImage.IsNotNull())
   {
     m_LabelSetImage->BeforeChangeLayerEvent -= mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
       this, &QmitkSimpleLabelSetListWidget::OnLooseLabelSetConnection);
     m_LabelSetImage->AfterChangeLayerEvent -= mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
       this, &QmitkSimpleLabelSetListWidget::OnEstablishLabelSetConnection);
     OnLooseLabelSetConnection();
   }
 }
 
 QmitkSimpleLabelSetListWidget::LabelVectorType QmitkSimpleLabelSetListWidget::SelectedLabels() const
 {
   auto selectedItems = m_LabelList->selectedItems();
   LabelVectorType result;
 
   QList<QListWidgetItem*>::Iterator it;
   for (it = selectedItems.begin(); it != selectedItems.end(); ++it)
   {
     auto labelValue = (*it)->data(Qt::UserRole).toUInt();
 
 
     auto activeLayerID = m_LabelSetImage->GetActiveLayer();
     auto labelSet = m_LabelSetImage->GetLabelSet(activeLayerID);
     
     result.push_back(labelSet->GetLabel(labelValue));
   }
 
   return result;
 }
 
 const mitk::LabelSetImage* QmitkSimpleLabelSetListWidget::GetLabelSetImage() const
 {
   return m_LabelSetImage;
 }
 
 void QmitkSimpleLabelSetListWidget::SetLabelSetImage(const mitk::LabelSetImage* image)
 {
   if (image != m_LabelSetImage)
   {
     if (m_LabelSetImage.IsNotNull())
     {
       m_LabelSetImage->BeforeChangeLayerEvent -= mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
         this, &QmitkSimpleLabelSetListWidget::OnLooseLabelSetConnection);
       m_LabelSetImage->AfterChangeLayerEvent -= mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
         this, &QmitkSimpleLabelSetListWidget::OnLayerChanged);
       this->OnLooseLabelSetConnection();
     }
 
     m_LabelSetImage = image;
 
     if (m_LabelSetImage.IsNotNull())
     {
       m_LabelSetImage->BeforeChangeLayerEvent += mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
         this, &QmitkSimpleLabelSetListWidget::OnLooseLabelSetConnection);
       m_LabelSetImage->AfterChangeLayerEvent += mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
         this, &QmitkSimpleLabelSetListWidget::OnLayerChanged);
       this->OnLayerChanged();
     }
   }
 }
 
 void QmitkSimpleLabelSetListWidget::OnLooseLabelSetConnection()
 {
   if (m_LabelSetImage.IsNull())
     return;
 
   auto activeLayerID = m_LabelSetImage->GetActiveLayer();
   auto labelSet = m_LabelSetImage->GetLabelSet(activeLayerID);
 
   // Reset LabelSetWidget Events
   labelSet->AddLabelEvent -= mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
     this, &QmitkSimpleLabelSetListWidget::OnLabelChanged);
   labelSet->RemoveLabelEvent -= mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
     this, &QmitkSimpleLabelSetListWidget::OnLabelChanged);
   labelSet->ModifyLabelEvent -= mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
     this, &QmitkSimpleLabelSetListWidget::OnLabelChanged);
 }
 
 void QmitkSimpleLabelSetListWidget::OnEstablishLabelSetConnection()
 {
   if (m_LabelSetImage.IsNull())
     return;
 
   auto activeLayerID = m_LabelSetImage->GetActiveLayer();
   auto labelSet = m_LabelSetImage->GetLabelSet(activeLayerID);
 
   // Reset LabelSetWidget Events
   labelSet->AddLabelEvent += mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
     this, &QmitkSimpleLabelSetListWidget::OnLabelChanged);
   labelSet->RemoveLabelEvent += mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
     this, &QmitkSimpleLabelSetListWidget::OnLabelChanged);
   labelSet->ModifyLabelEvent += mitk::MessageDelegate<QmitkSimpleLabelSetListWidget>(
     this, &QmitkSimpleLabelSetListWidget::OnLabelChanged);
 }
 
 void QmitkSimpleLabelSetListWidget::OnLayerChanged()
 {
   this->OnEstablishLabelSetConnection();
-  this->ResetList();
-  emit ActiveLayerChanged();
-  emit SelectedLabelsChanged(this->SelectedLabels());
+  if (!this->m_Emmiting)
+  {
+    this->ResetList();
+
+    this->m_Emmiting = true;
+    emit ActiveLayerChanged();
+    emit SelectedLabelsChanged(this->SelectedLabels());
+    this->m_Emmiting = false;
+  }
 }
 
 void QmitkSimpleLabelSetListWidget::OnLabelChanged()
 {
-  this->ResetList();
-  emit ActiveLayerChanged();
-  emit SelectedLabelsChanged(this->SelectedLabels());
+  if (!this->m_Emmiting)
+  {
+    this->ResetList();
+
+    this->m_Emmiting = true;
+    emit ActiveLayerChanged();
+    emit SelectedLabelsChanged(this->SelectedLabels());
+    this->m_Emmiting = false;
+  }
 }
 
 void QmitkSimpleLabelSetListWidget::OnLabelSelectionChanged()
 {
-  emit SelectedLabelsChanged(this->SelectedLabels());
+  if (!this->m_Emmiting)
+  {
+    this->m_Emmiting = true;
+    emit SelectedLabelsChanged(this->SelectedLabels());
+    this->m_Emmiting = false;
+  }
 }
 
 void QmitkSimpleLabelSetListWidget::ResetList()
 {
   m_LabelList->clear();
   
   auto activeLayerID = m_LabelSetImage->GetActiveLayer();
   auto labelSet = m_LabelSetImage->GetLabelSet(activeLayerID);
 
   auto iter = labelSet->IteratorConstBegin();
   for (; iter != labelSet->IteratorConstEnd(); ++iter)
   {
     auto color = iter->second->GetColor();
     QPixmap pixmap(10, 10);
     pixmap.fill(QColor(color[0] * 255, color[1] * 255, color[2] * 255));
     QIcon icon(pixmap);
 
     QListWidgetItem* item = new QListWidgetItem(icon, QString::fromStdString(iter->second->GetName()));
     item->setData(Qt::UserRole, QVariant(iter->second->GetValue()));
     m_LabelList->addItem(item);
   }
 }
 
 void QmitkSimpleLabelSetListWidget::SetSelectedLabels(const LabelVectorType& selectedLabels)
 {
   for (int i = 0; i < m_LabelList->count(); ++i)
   {
     QListWidgetItem* item = m_LabelList->item(i);
     auto labelValue = item->data(Qt::UserRole).toUInt();
 
     auto finding = std::find_if(selectedLabels.begin(), selectedLabels.end(), [labelValue](const mitk::Label* label) {return label->GetValue() == labelValue; });
     item->setSelected(finding != selectedLabels.end());
   }
 }
 
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSimpleLabelSetListWidget.h b/Modules/SegmentationUI/Qmitk/QmitkSimpleLabelSetListWidget.h
index 88c716ff0c..727be32c0e 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSimpleLabelSetListWidget.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkSimpleLabelSetListWidget.h
@@ -1,63 +1,64 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkSimpleLabelSetListWidget_h_Included
 #define QmitkSimpleLabelSetListWidget_h_Included
 
 #include "mitkLabel.h"
 #include "mitkLabelSetImage.h"
 #include <MitkSegmentationUIExports.h>
 #include <QListWidget>
 
 /**
   \brief Widget that offers a simple list that displays all labels (color and name) in the active
   layer of a LabelSetImage.
 */
 class MITKSEGMENTATIONUI_EXPORT QmitkSimpleLabelSetListWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   QmitkSimpleLabelSetListWidget(QWidget* parent = nullptr);
   ~QmitkSimpleLabelSetListWidget() override;
 
   using LabelVectorType = std::vector<mitk::Label::ConstPointer>;
 
   LabelVectorType SelectedLabels() const;
   const mitk::LabelSetImage* GetLabelSetImage() const;
 
 signals:
   void SelectedLabelsChanged(const LabelVectorType& selectedLabels);
   void ActiveLayerChanged();
 
 public slots :
   void SetLabelSetImage(const mitk::LabelSetImage* image);
   void SetSelectedLabels(const LabelVectorType& selectedLabels);
 
 protected slots:
 
   void OnLabelSelectionChanged();
 
 protected:
   void OnLayerChanged();
   void OnLabelChanged();
 
   void OnLooseLabelSetConnection();
   void OnEstablishLabelSetConnection();
 
   void ResetList();
 
   mitk::LabelSetImage::ConstPointer m_LabelSetImage;
   QListWidget* m_LabelList;
+  bool m_Emmiting;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.cpp b/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
index d731966d1f..e0f5f84b4d 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
@@ -1,710 +1,708 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkSliceBasedInterpolatorWidget.h"
 
 #include <mitkColorProperty.h>
 #include <mitkDiffSliceOperation.h>
 #include <mitkDiffSliceOperationApplier.h>
 #include <mitkExtractSliceFilter.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkLabelSetImage.h>
 #include <mitkOperationEvent.h>
 #include <mitkProgressBar.h>
 #include <mitkProperties.h>
 #include <mitkRenderingManager.h>
 #include <mitkSegTool2D.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkToolManager.h>
 #include <mitkToolManagerProvider.h>
 #include <mitkUndoController.h>
 #include <mitkVtkImageOverwrite.h>
 
-#include "QmitkStdMultiWidget.h"
-
 #include <itkCommand.h>
 
 #include <QApplication>
 #include <QCursor>
 #include <QMenu>
 #include <QMessageBox>
 
 QmitkSliceBasedInterpolatorWidget::QmitkSliceBasedInterpolatorWidget(QWidget *parent, const char * /*name*/)
   : QWidget(parent),
     m_SliceInterpolatorController(mitk::SliceBasedInterpolationController::New()),
     m_ToolManager(nullptr),
     m_Activated(false),
     m_DataStorage(nullptr),
     m_LastSNC(nullptr),
     m_LastSliceIndex(0)
 {
   m_Controls.setupUi(this);
 
-  m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
+  m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
 
   m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<QmitkSliceBasedInterpolatorWidget>(
     this, &QmitkSliceBasedInterpolatorWidget::OnToolManagerWorkingDataModified);
 
   connect(m_Controls.m_btStart, SIGNAL(toggled(bool)), this, SLOT(OnToggleWidgetActivation(bool)));
   connect(m_Controls.m_btApplyForCurrentSlice, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()));
   connect(m_Controls.m_btApplyForAllSlices, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()));
 
   itk::ReceptorMemberCommand<QmitkSliceBasedInterpolatorWidget>::Pointer command =
     itk::ReceptorMemberCommand<QmitkSliceBasedInterpolatorWidget>::New();
   command->SetCallbackFunction(this, &QmitkSliceBasedInterpolatorWidget::OnSliceInterpolationInfoChanged);
   m_InterpolationInfoChangedObserverTag = m_SliceInterpolatorController->AddObserver(itk::ModifiedEvent(), command);
 
   // feedback node and its visualization properties
   m_PreviewNode = mitk::DataNode::New();
   m_PreviewNode->SetName("3D tool preview");
 
   m_PreviewNode->SetProperty("texture interpolation", mitk::BoolProperty::New(false));
   m_PreviewNode->SetProperty("layer", mitk::IntProperty::New(100));
   m_PreviewNode->SetProperty("binary", mitk::BoolProperty::New(true));
   m_PreviewNode->SetProperty("outline binary", mitk::BoolProperty::New(true));
   m_PreviewNode->SetProperty("outline binary shadow", mitk::BoolProperty::New(true));
   m_PreviewNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_PreviewNode->SetOpacity(1.0);
   m_PreviewNode->SetColor(0.0, 1.0, 0.0);
 
   m_Controls.m_btApplyForCurrentSlice->setEnabled(false);
   m_Controls.m_btApplyForAllSlices->setEnabled(false);
 
   this->setEnabled(false);
 }
 
 QmitkSliceBasedInterpolatorWidget::~QmitkSliceBasedInterpolatorWidget()
 {
   m_ToolManager->WorkingDataChanged -= mitk::MessageDelegate<QmitkSliceBasedInterpolatorWidget>(
     this, &QmitkSliceBasedInterpolatorWidget::OnToolManagerWorkingDataModified);
 
   foreach (mitk::SliceNavigationController *slicer, m_ControllerToSliceObserverTag.keys())
   {
     slicer->RemoveObserver(m_ControllerToDeleteObserverTag.take(slicer));
     slicer->RemoveObserver(m_ControllerToTimeObserverTag.take(slicer));
     slicer->RemoveObserver(m_ControllerToSliceObserverTag.take(slicer));
   }
 
   m_ActionToSliceDimensionMap.clear();
 
   // remove observer
   m_SliceInterpolatorController->RemoveObserver(m_InterpolationInfoChangedObserverTag);
 }
 
 const QmitkSliceBasedInterpolatorWidget::ActionToSliceDimensionMapType
   QmitkSliceBasedInterpolatorWidget::CreateActionToSliceDimension()
 {
   ActionToSliceDimensionMapType actionToSliceDimension;
   foreach (mitk::SliceNavigationController *slicer, m_ControllerToDeleteObserverTag.keys())
   {
     std::string name = slicer->GetRenderer()->GetName();
     if (name == "stdmulti.widget0")
       name = "Axial (red window)";
     else if (name == "stdmulti.widget1")
       name = "Sagittal (green window)";
     else if (name == "stdmulti.widget2")
       name = "Coronal (blue window)";
     actionToSliceDimension[new QAction(QString::fromStdString(name), nullptr)] = slicer;
   }
 
   return actionToSliceDimension;
 }
 
 void QmitkSliceBasedInterpolatorWidget::SetDataStorage(mitk::DataStorage &storage)
 {
   m_DataStorage = &storage;
 }
 
 void QmitkSliceBasedInterpolatorWidget::SetSliceNavigationControllers(
   const QList<mitk::SliceNavigationController *> &controllers)
 {
   Q_ASSERT(!controllers.empty());
 
   // connect to the slice navigation controller. after each change, call the interpolator
   foreach (mitk::SliceNavigationController *slicer, controllers)
   {
     // Has to be initialized
     m_LastSNC = slicer;
 
     m_TimePoints.insert(slicer, slicer->GetSelectedTimePoint());
 
     itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::Pointer deleteCommand =
       itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::New();
     deleteCommand->SetCallbackFunction(this, &QmitkSliceBasedInterpolatorWidget::OnSliceNavigationControllerDeleted);
     m_ControllerToDeleteObserverTag.insert(slicer, slicer->AddObserver(itk::DeleteEvent(), deleteCommand));
 
     itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::Pointer timeChangedCommand =
       itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::New();
     timeChangedCommand->SetCallbackFunction(this, &QmitkSliceBasedInterpolatorWidget::OnTimeChanged);
     m_ControllerToTimeObserverTag.insert(
       slicer,
       slicer->AddObserver(mitk::SliceNavigationController::TimeGeometryEvent(nullptr, 0), timeChangedCommand));
 
     itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::Pointer sliceChangedCommand =
       itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::New();
     sliceChangedCommand->SetCallbackFunction(this, &QmitkSliceBasedInterpolatorWidget::OnSliceChanged);
     m_ControllerToSliceObserverTag.insert(
       slicer, slicer->AddObserver(mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), sliceChangedCommand));
   }
 
   m_ActionToSliceDimensionMap = this->CreateActionToSliceDimension();
 }
 
 void QmitkSliceBasedInterpolatorWidget::OnToolManagerWorkingDataModified()
 {
   mitk::DataNode *workingNode = this->m_ToolManager->GetWorkingData(0);
   if (!workingNode)
   {
     this->setEnabled(false);
     return;
   }
 
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
   // TODO adapt tool manager so that this check is done there, e.g. convenience function
   //  Q_ASSERT(workingImage);
   if (!workingImage)
   {
     this->setEnabled(false);
     return;
   }
 
   if (workingImage->GetDimension() > 4 || workingImage->GetDimension() < 3)
   {
     this->setEnabled(false);
     return;
   }
 
   m_WorkingImage = workingImage;
 
   this->setEnabled(true);
 }
 
 void QmitkSliceBasedInterpolatorWidget::OnTimeChanged(itk::Object *sender, const itk::EventObject &e)
 {
   // Check if we really have a GeometryTimeEvent
   if (!dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent *>(&e))
     return;
 
   mitk::SliceNavigationController *slicer = dynamic_cast<mitk::SliceNavigationController *>(sender);
   Q_ASSERT(slicer);
 
   m_TimePoints[slicer] = slicer->GetSelectedTimePoint();
 
   // TODO Macht das hier wirklich Sinn????
   if (m_LastSNC == slicer)
   {
     slicer->SendSlice(); // will trigger a new interpolation
   }
 }
 
 void QmitkSliceBasedInterpolatorWidget::OnSliceChanged(itk::Object *sender, const itk::EventObject &e)
 {
   if (m_Activated && m_WorkingImage.IsNotNull())
   {
     // Check whether we really have a GeometrySliceEvent
     if (!dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent *>(&e))
       return;
 
     mitk::SliceNavigationController *slicer = dynamic_cast<mitk::SliceNavigationController *>(sender);
     if (slicer)
     {
       this->TranslateAndInterpolateChangedSlice(e, slicer);
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       //  slicer->GetRenderer()->RequestUpdate();
     }
   }
 }
 
 void QmitkSliceBasedInterpolatorWidget::TranslateAndInterpolateChangedSlice(const itk::EventObject &e,
                                                                             mitk::SliceNavigationController *slicer)
 {
   if (m_Activated && m_WorkingImage.IsNotNull())
   {
     const mitk::SliceNavigationController::GeometrySliceEvent &geometrySliceEvent =
       dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent &>(e);
     mitk::TimeGeometry *timeGeometry = geometrySliceEvent.GetTimeGeometry();
     if (timeGeometry && m_TimePoints.contains(slicer) && timeGeometry->IsValidTimePoint(m_TimePoints[slicer]))
     {
       mitk::SlicedGeometry3D *slicedGeometry =
         dynamic_cast<mitk::SlicedGeometry3D *>(timeGeometry->GetGeometryForTimePoint(m_TimePoints[slicer]).GetPointer());
       if (slicedGeometry)
       {
         mitk::PlaneGeometry *plane = slicedGeometry->GetPlaneGeometry(geometrySliceEvent.GetPos());
         if (plane)
         {
           m_LastSNC = slicer;
           this->Interpolate(plane, m_TimePoints[slicer], slicer);
         }
       }
     }
   }
 }
 
 void QmitkSliceBasedInterpolatorWidget::Interpolate(mitk::PlaneGeometry *plane,
                                                     mitk::TimePointType timePoint,
                                                     mitk::SliceNavigationController *slicer)
 {
   int clickedSliceDimension(-1);
   int clickedSliceIndex(-1);
 
   if (!m_WorkingImage->GetTimeGeometry()->IsValidTimePoint(timePoint))
   {
     MITK_WARN << "Cannot interpolate WorkingImage. Passed time point is not within the time bounds of WorkingImage. Time point: " << timePoint;
     return;
   }
   const auto timeStep = m_WorkingImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
 
   // calculate real slice position, i.e. slice of the image
   // see if timestep is needed here
   mitk::SegTool2D::DetermineAffectedImageSlice(m_WorkingImage, plane, clickedSliceDimension, clickedSliceIndex);
 
   mitk::Image::Pointer interpolation =
     m_SliceInterpolatorController->Interpolate(clickedSliceDimension, clickedSliceIndex, plane, timeStep);
 
   m_PreviewNode->SetData(interpolation);
 
   const mitk::Color &color = m_WorkingImage->GetActiveLabel()->GetColor();
   m_PreviewNode->SetColor(color);
 
   m_LastSNC = slicer;
   m_LastSliceIndex = clickedSliceIndex;
 }
 
 mitk::Image::Pointer QmitkSliceBasedInterpolatorWidget::GetWorkingSlice(const mitk::PlaneGeometry *planeGeometry)
 {
   const auto timePoint = m_LastSNC->GetSelectedTimePoint();
 
   if (!m_WorkingImage->GetTimeGeometry()->IsValidTimePoint(timePoint))
   {
     MITK_WARN << "Cannot get slice of WorkingImage. Time point selected by SliceNavigationController is not within the time bounds of WorkingImage. Time point: " << timePoint;
     return nullptr;
   }
 
   // Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
   // reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   // set to false to extract a slice
   reslice->SetOverwriteMode(false);
   reslice->Modified();
 
   // use ExtractSliceFilter with our specific vtkImageReslice for overwriting and extracting
   mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput(m_WorkingImage);
   const auto timeStep = m_WorkingImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
   extractor->SetTimeStep(timeStep);
   extractor->SetWorldGeometry(planeGeometry);
   extractor->SetVtkOutputRequest(false);
   extractor->SetResliceTransformByGeometry(m_WorkingImage->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
 
   extractor->Modified();
 
   try
   {
     extractor->Update();
   }
   catch (itk::ExceptionObject &excep)
   {
     MITK_ERROR << "Exception caught: " << excep.GetDescription();
     return nullptr;
   }
 
   mitk::Image::Pointer slice = extractor->GetOutput();
 
   // specify the undo operation with the non edited slice
   // MLI TODO added code starts here
   mitk::SlicedGeometry3D *sliceGeometry = dynamic_cast<mitk::SlicedGeometry3D *>(slice->GetGeometry());
   // m_undoOperation = new mitk::DiffSliceOperation(m_WorkingImage, extractor->GetVtkOutput(), slice->GetGeometry(),
   // timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
   // added code ends here
   m_undoOperation = new mitk::DiffSliceOperation(
     m_WorkingImage, extractor->GetOutput(), sliceGeometry, timeStep, const_cast<mitk::PlaneGeometry *>(planeGeometry));
 
   slice->DisconnectPipeline();
 
   return slice;
 }
 
 void QmitkSliceBasedInterpolatorWidget::OnToggleWidgetActivation(bool enabled)
 {
   Q_ASSERT(m_ToolManager);
 
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   if (!workingNode)
     return;
 
   m_Controls.m_btApplyForCurrentSlice->setEnabled(enabled);
   m_Controls.m_btApplyForAllSlices->setEnabled(enabled);
 
   if (enabled)
     m_Controls.m_btStart->setText("Stop");
   else
     m_Controls.m_btStart->setText("Start");
 
   unsigned int numberOfExistingTools = m_ToolManager->GetTools().size();
   for (unsigned int i = 0; i < numberOfExistingTools; i++)
   {
     // mitk::SegTool2D* tool = dynamic_cast<mitk::SegTool2D*>(m_ToolManager->GetToolById(i));
     // MLI TODO
     // if (tool) tool->SetEnable2DInterpolation( enabled );
   }
 
   if (enabled)
   {
     if (!m_DataStorage->Exists(m_PreviewNode))
     {
       m_DataStorage->Add(m_PreviewNode);
     }
 
     m_SliceInterpolatorController->SetWorkingImage(m_WorkingImage);
     this->UpdateVisibleSuggestion();
   }
   else
   {
     if (m_DataStorage->Exists(m_PreviewNode))
     {
       m_DataStorage->Remove(m_PreviewNode);
     }
 
     mitk::UndoController::GetCurrentUndoModel()->Clear();
   }
 
   m_Activated = enabled;
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void QmitkSliceBasedInterpolatorWidget::WritePreviewOnWorkingImage(itk::Image<TPixel, VImageDimension> *targetSlice,
                                                                    const mitk::Image *sourceSlice,
                                                                    int overwritevalue)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
 
   typename ImageType::Pointer sourceSliceITK;
   mitk::CastToItkImage(sourceSlice, sourceSliceITK);
 
   // now the original slice and the ipSegmentation-painted slice are in the same format, and we can just copy all pixels
   // that are non-zero
   typedef itk::ImageRegionIterator<ImageType> OutputIteratorType;
   typedef itk::ImageRegionConstIterator<ImageType> InputIteratorType;
 
   InputIteratorType inputIterator(sourceSliceITK, sourceSliceITK->GetLargestPossibleRegion());
   OutputIteratorType outputIterator(targetSlice, targetSlice->GetLargestPossibleRegion());
 
   outputIterator.GoToBegin();
   inputIterator.GoToBegin();
 
   int activePixelValue = m_WorkingImage->GetActiveLabel()->GetValue();
 
   if (activePixelValue == 0) // if exterior is the active label
   {
     while (!outputIterator.IsAtEnd())
     {
       if (inputIterator.Get() != 0)
       {
         outputIterator.Set(overwritevalue);
       }
       ++outputIterator;
       ++inputIterator;
     }
   }
   else if (overwritevalue != 0) // if we are not erasing
   {
     while (!outputIterator.IsAtEnd())
     {
       int targetValue = static_cast<int>(outputIterator.Get());
       if (inputIterator.Get() != 0)
       {
         if (!m_WorkingImage->GetLabel(targetValue)->GetLocked())
           outputIterator.Set(overwritevalue);
       }
 
       ++outputIterator;
       ++inputIterator;
     }
   }
   else // if we are erasing
   {
     while (!outputIterator.IsAtEnd())
     {
       const int targetValue = outputIterator.Get();
       if (inputIterator.Get() != 0)
       {
         if (targetValue == activePixelValue)
           outputIterator.Set(overwritevalue);
       }
 
       ++outputIterator;
       ++inputIterator;
     }
   }
 }
 
 void QmitkSliceBasedInterpolatorWidget::OnAcceptInterpolationClicked()
 {
   if (m_WorkingImage.IsNotNull() && m_PreviewNode->GetData())
   {
     const mitk::PlaneGeometry *planeGeometry = m_LastSNC->GetCurrentPlaneGeometry();
     if (!planeGeometry)
       return;
 
     mitk::Image::Pointer sliceImage = this->GetWorkingSlice(planeGeometry);
     if (sliceImage.IsNull())
       return;
 
     mitk::Image::Pointer previewSlice = dynamic_cast<mitk::Image *>(m_PreviewNode->GetData());
 
     AccessFixedDimensionByItk_2(
       sliceImage, WritePreviewOnWorkingImage, 2, previewSlice, m_WorkingImage->GetActiveLabel()->GetValue());
 
     // Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
     // reslicer
     vtkSmartPointer<mitkVtkImageOverwrite> overwrite = vtkSmartPointer<mitkVtkImageOverwrite>::New();
     overwrite->SetInputSlice(sliceImage->GetVtkImageData());
     // set overwrite mode to true to write back to the image volume
     overwrite->SetOverwriteMode(true);
     overwrite->Modified();
 
     const auto timePoint = m_LastSNC->GetSelectedTimePoint();
     if (!m_WorkingImage->GetTimeGeometry()->IsValidTimePoint(timePoint))
     {
       MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationController is not within the time bounds of WorkingImage. Time point: " << timePoint;
       return;
     }
 
     mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(overwrite);
     extractor->SetInput(m_WorkingImage);
     const auto timeStep = m_WorkingImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
     extractor->SetTimeStep(timeStep);
     extractor->SetWorldGeometry(planeGeometry);
     extractor->SetVtkOutputRequest(false);
     extractor->SetResliceTransformByGeometry(m_WorkingImage->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
 
     extractor->Modified();
 
     try
     {
       extractor->Update();
     }
     catch (itk::ExceptionObject &excep)
     {
       MITK_ERROR << "Exception caught: " << excep.GetDescription();
       return;
     }
 
     // the image was modified within the pipeline, but not marked so
     m_WorkingImage->Modified();
 
     int clickedSliceDimension(-1);
     int clickedSliceIndex(-1);
 
     mitk::SegTool2D::DetermineAffectedImageSlice(
       m_WorkingImage, planeGeometry, clickedSliceDimension, clickedSliceIndex);
 
     m_SliceInterpolatorController->SetChangedSlice(sliceImage, clickedSliceDimension, clickedSliceIndex, timeStep);
 
     // specify the undo operation with the edited slice
     // MLI TODO added code starts here
     mitk::SlicedGeometry3D *sliceGeometry = dynamic_cast<mitk::SlicedGeometry3D *>(sliceImage->GetGeometry());
     // m_undoOperation = new mitk::DiffSliceOperation(m_WorkingImage, extractor->GetVtkOutput(), slice->GetGeometry(),
     // timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
     // added code ends here
     m_doOperation = new mitk::DiffSliceOperation(m_WorkingImage,
                                                  extractor->GetOutput(),
                                                  sliceGeometry,
                                                  timeStep,
                                                  const_cast<mitk::PlaneGeometry *>(planeGeometry));
 
     // create an operation event for the undo stack
     mitk::OperationEvent *undoStackItem = new mitk::OperationEvent(
       mitk::DiffSliceOperationApplier::GetInstance(), m_doOperation, m_undoOperation, "Slice Interpolation");
 
     // add it to the undo controller
     mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
 
     // clear the pointers as the operation are stored in the undo controller and also deleted from there
     m_undoOperation = nullptr;
     m_doOperation = nullptr;
 
     m_PreviewNode->SetData(nullptr);
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSliceBasedInterpolatorWidget::AcceptAllInterpolations(mitk::SliceNavigationController *slicer)
 {
   // Since we need to shift the plane it must be clone so that the original plane isn't altered
   mitk::PlaneGeometry::Pointer reslicePlane = slicer->GetCurrentPlaneGeometry()->Clone();
   const auto timePoint = slicer->GetSelectedTimePoint();
   if (!m_WorkingImage->GetTimeGeometry()->IsValidTimePoint(timePoint))
   {
     MITK_WARN << "Cannot accept all interpolations. Time point selected by SliceNavigationController is not within the time bounds of WorkingImage. Time point: " << timePoint;
 
     return;
   }
   const auto timeStep = m_WorkingImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
 
   int sliceDimension(-1);
   int sliceIndex(-1);
 
   mitk::SegTool2D::DetermineAffectedImageSlice(m_WorkingImage, reslicePlane, sliceDimension, sliceIndex);
 
   unsigned int zslices = m_WorkingImage->GetDimension(sliceDimension);
 
   mitk::ProgressBar::GetInstance()->Reset();
   mitk::ProgressBar::GetInstance()->AddStepsToDo(zslices);
 
   mitk::Point3D origin = reslicePlane->GetOrigin();
 
   for (unsigned int idx = 0; idx < zslices; ++idx)
   {
     // Transforming the current origin of the reslice plane
     // so that it matches the one of the next slice
     m_WorkingImage->GetSlicedGeometry()->WorldToIndex(origin, origin);
     origin[sliceDimension] = idx;
     m_WorkingImage->GetSlicedGeometry()->IndexToWorld(origin, origin);
     reslicePlane->SetOrigin(origin);
 
     mitk::Image::Pointer interpolation =
       m_SliceInterpolatorController->Interpolate(sliceDimension, idx, reslicePlane, timeStep);
 
     if (interpolation.IsNotNull())
     {
       m_PreviewNode->SetData(interpolation);
 
       mitk::Image::Pointer sliceImage = this->GetWorkingSlice(reslicePlane);
       if (sliceImage.IsNull())
         return;
 
       AccessFixedDimensionByItk_2(
         sliceImage, WritePreviewOnWorkingImage, 2, interpolation, m_WorkingImage->GetActiveLabel()->GetValue());
 
       // Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
       // reslicer
       vtkSmartPointer<mitkVtkImageOverwrite> overwrite = vtkSmartPointer<mitkVtkImageOverwrite>::New();
       overwrite->SetInputSlice(sliceImage->GetVtkImageData());
       // set overwrite mode to true to write back to the image volume
       overwrite->SetOverwriteMode(true);
       overwrite->Modified();
 
       mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(overwrite);
       extractor->SetInput(m_WorkingImage);
       extractor->SetTimeStep(timeStep);
       extractor->SetWorldGeometry(reslicePlane);
       extractor->SetVtkOutputRequest(true);
       extractor->SetResliceTransformByGeometry(m_WorkingImage->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
 
       extractor->Modified();
 
       try
       {
         extractor->Update();
       }
       catch (itk::ExceptionObject &excep)
       {
         MITK_ERROR << "Exception caught: " << excep.GetDescription();
         return;
       }
 
       m_WorkingImage->Modified();
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
     }
 
     mitk::ProgressBar::GetInstance()->Progress();
   }
 
   m_SliceInterpolatorController->SetWorkingImage(m_WorkingImage);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSliceBasedInterpolatorWidget::OnAcceptAllInterpolationsClicked()
 {
   QMenu orientationPopup(this);
   std::map<QAction *, mitk::SliceNavigationController *>::const_iterator it;
   for (it = m_ActionToSliceDimensionMap.begin(); it != m_ActionToSliceDimensionMap.end(); it++)
     orientationPopup.addAction(it->first);
 
   connect(&orientationPopup, SIGNAL(triggered(QAction *)), this, SLOT(OnAcceptAllPopupActivated(QAction *)));
 
   orientationPopup.exec(QCursor::pos());
 }
 
 void QmitkSliceBasedInterpolatorWidget::OnAcceptAllPopupActivated(QAction *action)
 {
   ActionToSliceDimensionMapType::const_iterator iter = m_ActionToSliceDimensionMap.find(action);
   if (iter != m_ActionToSliceDimensionMap.end())
   {
     mitk::SliceNavigationController *slicer = iter->second;
     this->AcceptAllInterpolations(slicer);
   }
 }
 
 void QmitkSliceBasedInterpolatorWidget::UpdateVisibleSuggestion()
 {
   if (m_Activated && m_LastSNC)
   {
     // determine which one is the current view, try to do an initial interpolation
     mitk::BaseRenderer *renderer = m_LastSNC->GetRenderer();
     if (renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
     {
       const mitk::TimeGeometry *timeGeometry =
         dynamic_cast<const mitk::TimeGeometry *>(renderer->GetWorldTimeGeometry());
       if (timeGeometry)
       {
         mitk::SliceNavigationController::GeometrySliceEvent event(const_cast<mitk::TimeGeometry *>(timeGeometry),
                                                                   renderer->GetSlice());
         this->TranslateAndInterpolateChangedSlice(event, m_LastSNC);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
     }
   }
 }
 
 void QmitkSliceBasedInterpolatorWidget::OnSliceInterpolationInfoChanged(const itk::EventObject & /*e*/)
 {
   // something (e.g. undo) changed the interpolation info, we should refresh our display
   this->UpdateVisibleSuggestion();
 }
 
 void QmitkSliceBasedInterpolatorWidget::OnSliceNavigationControllerDeleted(const itk::Object *sender,
                                                                            const itk::EventObject & /*e*/)
 {
   // Don't know how to avoid const_cast here?!
   mitk::SliceNavigationController *slicer =
     dynamic_cast<mitk::SliceNavigationController *>(const_cast<itk::Object *>(sender));
   if (slicer)
   {
     m_ControllerToTimeObserverTag.remove(slicer);
     m_ControllerToSliceObserverTag.remove(slicer);
     m_ControllerToDeleteObserverTag.remove(slicer);
   }
 }
 
 void QmitkSliceBasedInterpolatorWidget::WaitCursorOn()
 {
   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 }
 
 void QmitkSliceBasedInterpolatorWidget::WaitCursorOff()
 {
   this->RestoreOverrideCursor();
 }
 
 void QmitkSliceBasedInterpolatorWidget::RestoreOverrideCursor()
 {
   QApplication::restoreOverrideCursor();
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.h b/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.h
index b447a67e11..86c6cdab0a 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.h
@@ -1,197 +1,195 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkSliceBasedInterpolatorWidget_h_Included
 #define QmitkSliceBasedInterpolatorWidget_h_Included
 
 #include "MitkSegmentationUIExports.h"
 #include "mitkDataStorage.h"
 #include "mitkSliceBasedInterpolationController.h"
 
 #include <map>
 
 #include <QWidget>
 
 #include "ui_QmitkSliceBasedInterpolatorWidgetGUIControls.h"
 
 namespace mitk
 {
   class PlaneGeometry;
   class SliceNavigationController;
   class LabelSetImage;
   class ToolManager;
   class DiffSliceOperation;
 }
 
 /**
   \brief GUI for slices interpolation.
 
   \ingroup ToolManagerEtAl
   \ingroup Widgets
 
   \sa QmitkInteractiveSegmentation
   \sa mitk::SegmentationInterpolation
 
   While mitk::SegmentationInterpolation does the bookkeeping of interpolation
   (keeping track of which slices contain how much segmentation) and the algorithmic work,
   QmitkSliceBasedInterpolatorWidget is responsible to watch the GUI, to notice, which slice is currently
   visible. It triggers generation of interpolation suggestions and also triggers acception of
   suggestions.
 
-  This class uses the mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION context.
-
   \todo show/hide feedback on demand
 
   Last contributor: $Author: maleike $
 */
 
 class MITKSEGMENTATIONUI_EXPORT QmitkSliceBasedInterpolatorWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   QmitkSliceBasedInterpolatorWidget(QWidget *parent = nullptr, const char *name = nullptr);
   ~QmitkSliceBasedInterpolatorWidget() override;
 
   void SetDataStorage(mitk::DataStorage &storage);
 
   /**
     Sets the slice navigation controllers for getting slice changed events from the views.
   */
   void SetSliceNavigationControllers(const QList<mitk::SliceNavigationController *> &controllers);
 
   void OnToolManagerWorkingDataModified();
 
   void OnTimeChanged(itk::Object *sender, const itk::EventObject &);
 
   void OnSliceChanged(itk::Object *sender, const itk::EventObject &);
 
   void OnSliceNavigationControllerDeleted(const itk::Object *sender, const itk::EventObject &);
 
   /**
     Just public because it is called by itk::Commands. You should not need to call this.
   */
   void OnSliceInterpolationInfoChanged(const itk::EventObject &);
 
   Ui::QmitkSliceBasedInterpolatorWidgetGUIControls m_Controls;
 
 signals:
 
   void signalSliceBasedInterpolationEnabled(bool);
 
 public slots:
 
   /**
     \brief Reaction to "Start/Stop" button click
   */
   void OnToggleWidgetActivation(bool);
 
 protected slots:
 
   /**
     \brief Reaction to "Accept Current Slice" button click.
   */
   void OnAcceptInterpolationClicked();
 
   /*
     \brief Reaction to "Accept All Slices" button click.
     Opens popup to ask about which orientation should be interpolated
   */
   void OnAcceptAllInterpolationsClicked();
 
   /*
     \brief Called from popup menu of OnAcceptAllInterpolationsClicked()
      Will trigger interpolation for all slices in given orientation
   */
   void OnAcceptAllPopupActivated(QAction *action);
 
 protected:
   typedef std::map<QAction *, mitk::SliceNavigationController *> ActionToSliceDimensionMapType;
 
   const ActionToSliceDimensionMapType CreateActionToSliceDimension();
 
   ActionToSliceDimensionMapType m_ActionToSliceDimensionMap;
 
   void AcceptAllInterpolations(mitk::SliceNavigationController *slicer);
 
   void WaitCursorOn();
 
   void WaitCursorOff();
 
   void RestoreOverrideCursor();
 
   /**
     Gets the working slice based on the given plane geometry and last saved interaction
 
     \param planeGeometry a plane geometry
   */
   mitk::Image::Pointer GetWorkingSlice(const mitk::PlaneGeometry *planeGeometry);
 
   /**
     Retrieves the currently selected PlaneGeometry from a SlicedGeometry3D that is generated by a
     SliceNavigationController
     and calls Interpolate to further process this PlaneGeometry into an interpolation.
 
     \param e is a actually a mitk::SliceNavigationController::GeometrySliceEvent, sent by a SliceNavigationController
     \param slicer the SliceNavigationController
   */
   void TranslateAndInterpolateChangedSlice(const itk::EventObject &e, mitk::SliceNavigationController *slicer);
 
   /**
     Given a PlaneGeometry, this method figures out which slice of the first working image (of the associated
     ToolManager)
     should be interpolated. The actual work is then done by our SegmentationInterpolation object.
   */
   void Interpolate(mitk::PlaneGeometry *plane, mitk::TimePointType timePoint, mitk::SliceNavigationController *slicer);
 
   /**
     Called internally to update the interpolation suggestion. Finds out about the focused render window and requests an
     interpolation.
    */
   void UpdateVisibleSuggestion();
 
 private:
   mitk::SliceBasedInterpolationController::Pointer m_SliceInterpolatorController;
 
   mitk::ToolManager *m_ToolManager;
 
   bool m_Activated;
 
   template <typename TPixel, unsigned int VImageDimension>
   void WritePreviewOnWorkingImage(itk::Image<TPixel, VImageDimension> *target,
                                   const mitk::Image *source,
                                   int overwritevalue);
 
   QHash<mitk::SliceNavigationController *, int> m_ControllerToTimeObserverTag;
   QHash<mitk::SliceNavigationController *, int> m_ControllerToSliceObserverTag;
   QHash<mitk::SliceNavigationController *, int> m_ControllerToDeleteObserverTag;
 
   unsigned int m_InterpolationInfoChangedObserverTag;
 
   mitk::DiffSliceOperation *m_doOperation;
   mitk::DiffSliceOperation *m_undoOperation;
 
   mitk::DataNode::Pointer m_PreviewNode;
   mitk::Image::Pointer m_PreviewImage;
 
   mitk::LabelSetImage::Pointer m_WorkingImage;
 
   QHash<mitk::SliceNavigationController *, mitk::TimePointType> m_TimePoints;
 
   mitk::DataStorage::Pointer m_DataStorage;
 
   mitk::SliceNavigationController *m_LastSNC;
 
   unsigned int m_LastSliceIndex;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
index e41f25d83b..cb067cfd3f 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
@@ -1,1442 +1,1441 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkSlicesInterpolator.h"
 
 #include "QmitkSelectableGLWidget.h"
-#include "QmitkStdMultiWidget.h"
 
 #include "mitkApplyDiffImageOperation.h"
 #include "mitkColorProperty.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkDiffImageApplier.h"
 #include "mitkInteractionConst.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkOperationEvent.h"
 #include "mitkProgressBar.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkSegTool2D.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkSurfaceToImageFilter.h"
 #include "mitkToolManager.h"
 #include "mitkUndoController.h"
 #include <mitkExtractSliceFilter.h>
 #include <mitkImageReadAccessor.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkPlaneProposer.h>
 #include <mitkUnstructuredGridClusteringFilter.h>
 #include <mitkVtkImageOverwrite.h>
 #include <mitkShapeBasedInterpolationAlgorithm.h>
 
 #include <itkCommand.h>
 
 #include <QCheckBox>
 #include <QCursor>
 #include <QMenu>
 #include <QMessageBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 #include <vtkPolyVertex.h>
 #include <vtkUnstructuredGrid.h>
 
 #include <array>
 #include <atomic>
 #include <thread>
 #include <vector>
 
 namespace
 {
   template <typename T = mitk::BaseData>
   itk::SmartPointer<T> GetData(const mitk::DataNode* dataNode)
   {
     return nullptr != dataNode
       ? dynamic_cast<T*>(dataNode->GetData())
       : nullptr;
   }
 }
 
 float SURFACE_COLOR_RGB[3] = {0.49f, 1.0f, 0.16f};
 
 const std::map<QAction *, mitk::SliceNavigationController *> QmitkSlicesInterpolator::createActionToSliceDimension()
 {
   std::map<QAction *, mitk::SliceNavigationController *> actionToSliceDimension;
   foreach (mitk::SliceNavigationController *slicer, m_ControllerToDeleteObserverTag.keys())
   {
     actionToSliceDimension[new QAction(QString::fromStdString(slicer->GetViewDirectionAsString()), nullptr)] = slicer;
   }
 
   return actionToSliceDimension;
 }
 
 QmitkSlicesInterpolator::QmitkSlicesInterpolator(QWidget *parent, const char * /*name*/)
   : QWidget(parent),
     //    ACTION_TO_SLICEDIMENSION( createActionToSliceDimension() ),
     m_Interpolator(mitk::SegmentationInterpolationController::New()),
     m_SurfaceInterpolator(mitk::SurfaceInterpolationController::GetInstance()),
     m_ToolManager(nullptr),
     m_Initialized(false),
     m_LastSNC(nullptr),
     m_LastSliceIndex(0),
     m_2DInterpolationEnabled(false),
     m_3DInterpolationEnabled(false),
     m_FirstRun(true)
 {
   m_GroupBoxEnableExclusiveInterpolationMode = new QGroupBox("Interpolation", this);
 
   QVBoxLayout *vboxLayout = new QVBoxLayout(m_GroupBoxEnableExclusiveInterpolationMode);
 
   m_EdgeDetector = mitk::FeatureBasedEdgeDetectionFilter::New();
   m_PointScorer = mitk::PointCloudScoringFilter::New();
 
   m_CmbInterpolation = new QComboBox(m_GroupBoxEnableExclusiveInterpolationMode);
   m_CmbInterpolation->addItem("Disabled");
   m_CmbInterpolation->addItem("2-Dimensional");
   m_CmbInterpolation->addItem("3-Dimensional");
   vboxLayout->addWidget(m_CmbInterpolation);
 
   m_BtnApply2D = new QPushButton("Confirm for single slice", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_BtnApply2D);
 
   m_BtnApplyForAllSlices2D = new QPushButton("Confirm for all slices", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_BtnApplyForAllSlices2D);
 
   m_BtnApply3D = new QPushButton("Confirm", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_BtnApply3D);
 
   // T28261
   // m_BtnSuggestPlane = new QPushButton("Suggest a plane", m_GroupBoxEnableExclusiveInterpolationMode);
   // vboxLayout->addWidget(m_BtnSuggestPlane);
 
   m_BtnReinit3DInterpolation = new QPushButton("Reinit Interpolation", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_BtnReinit3DInterpolation);
 
   m_ChkShowPositionNodes = new QCheckBox("Show Position Nodes", m_GroupBoxEnableExclusiveInterpolationMode);
   vboxLayout->addWidget(m_ChkShowPositionNodes);
 
   this->HideAllInterpolationControls();
 
   connect(m_CmbInterpolation, SIGNAL(currentIndexChanged(int)), this, SLOT(OnInterpolationMethodChanged(int)));
   connect(m_BtnApply2D, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()));
   connect(m_BtnApplyForAllSlices2D, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()));
   connect(m_BtnApply3D, SIGNAL(clicked()), this, SLOT(OnAccept3DInterpolationClicked()));
 
   // T28261
   // connect(m_BtnSuggestPlane, SIGNAL(clicked()), this, SLOT(OnSuggestPlaneClicked()));
 
   connect(m_BtnReinit3DInterpolation, SIGNAL(clicked()), this, SLOT(OnReinit3DInterpolation()));
   connect(m_ChkShowPositionNodes, SIGNAL(toggled(bool)), this, SLOT(OnShowMarkers(bool)));
   connect(m_ChkShowPositionNodes, SIGNAL(toggled(bool)), this, SIGNAL(SignalShowMarkerNodes(bool)));
 
   QHBoxLayout *layout = new QHBoxLayout(this);
   layout->addWidget(m_GroupBoxEnableExclusiveInterpolationMode);
   this->setLayout(layout);
 
   itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command =
     itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
   command->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnInterpolationInfoChanged);
   InterpolationInfoChangedObserverTag = m_Interpolator->AddObserver(itk::ModifiedEvent(), command);
 
   itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command2 =
     itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
   command2->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged);
   SurfaceInterpolationInfoChangedObserverTag = m_SurfaceInterpolator->AddObserver(itk::ModifiedEvent(), command2);
 
   auto command3 = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
   command3->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnInterpolationAborted);
   InterpolationAbortedObserverTag = m_Interpolator->AddObserver(itk::AbortEvent(), command3);
 
   // feedback node and its visualization properties
   m_FeedbackNode = mitk::DataNode::New();
   mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties(m_FeedbackNode);
 
   m_FeedbackNode->SetProperty("binary", mitk::BoolProperty::New(true));
   m_FeedbackNode->SetProperty("outline binary", mitk::BoolProperty::New(true));
   m_FeedbackNode->SetProperty("color", mitk::ColorProperty::New(255.0, 255.0, 0.0));
   m_FeedbackNode->SetProperty("texture interpolation", mitk::BoolProperty::New(false));
   m_FeedbackNode->SetProperty("layer", mitk::IntProperty::New(20));
   m_FeedbackNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
   m_FeedbackNode->SetProperty("name", mitk::StringProperty::New("Interpolation feedback"));
   m_FeedbackNode->SetProperty("opacity", mitk::FloatProperty::New(0.8));
   m_FeedbackNode->SetProperty("helper object", mitk::BoolProperty::New(true));
 
   m_InterpolatedSurfaceNode = mitk::DataNode::New();
   m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(SURFACE_COLOR_RGB));
   m_InterpolatedSurfaceNode->SetProperty("name", mitk::StringProperty::New("Surface Interpolation feedback"));
   m_InterpolatedSurfaceNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
   m_InterpolatedSurfaceNode->SetProperty("line width", mitk::FloatProperty::New(4.0f));
   m_InterpolatedSurfaceNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_InterpolatedSurfaceNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_InterpolatedSurfaceNode->SetVisibility(false);
 
   m_3DContourNode = mitk::DataNode::New();
   m_3DContourNode->SetProperty("color", mitk::ColorProperty::New(0.0, 0.0, 0.0));
   m_3DContourNode->SetProperty("hidden object", mitk::BoolProperty::New(true));
   m_3DContourNode->SetProperty("name", mitk::StringProperty::New("Drawn Contours"));
   m_3DContourNode->SetProperty("material.representation", mitk::VtkRepresentationProperty::New(VTK_WIREFRAME));
   m_3DContourNode->SetProperty("material.wireframeLineWidth", mitk::FloatProperty::New(2.0f));
   m_3DContourNode->SetProperty("3DContourContainer", mitk::BoolProperty::New(true));
   m_3DContourNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_3DContourNode->SetVisibility(
     false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0")));
   m_3DContourNode->SetVisibility(
     false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
   m_3DContourNode->SetVisibility(
     false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")));
   m_3DContourNode->SetVisibility(
     false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
 
   QWidget::setContentsMargins(0, 0, 0, 0);
   if (QWidget::layout() != nullptr)
   {
     QWidget::layout()->setContentsMargins(0, 0, 0, 0);
   }
 
   // For running 3D Interpolation in background
   // create a QFuture and a QFutureWatcher
 
   connect(&m_Watcher, SIGNAL(started()), this, SLOT(StartUpdateInterpolationTimer()));
   connect(&m_Watcher, SIGNAL(finished()), this, SLOT(OnSurfaceInterpolationFinished()));
   connect(&m_Watcher, SIGNAL(finished()), this, SLOT(StopUpdateInterpolationTimer()));
   m_Timer = new QTimer(this);
   connect(m_Timer, SIGNAL(timeout()), this, SLOT(ChangeSurfaceColor()));
 }
 
 void QmitkSlicesInterpolator::SetDataStorage(mitk::DataStorage::Pointer storage)
 {
   if (m_DataStorage == storage)
   {
     return;
   }
 
   if (m_DataStorage.IsNotNull())
   {
     m_DataStorage->RemoveNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkSlicesInterpolator, const mitk::DataNode*>(this, &QmitkSlicesInterpolator::NodeRemoved)
     );
   }
 
   m_DataStorage = storage;
   m_SurfaceInterpolator->SetDataStorage(storage);
 
   if (m_DataStorage.IsNotNull())
   {
     m_DataStorage->RemoveNodeEvent.AddListener(
       mitk::MessageDelegate1<QmitkSlicesInterpolator, const mitk::DataNode*>(this, &QmitkSlicesInterpolator::NodeRemoved)
     );
   }
 }
 
 mitk::DataStorage *QmitkSlicesInterpolator::GetDataStorage()
 {
   if (m_DataStorage.IsNotNull())
   {
     return m_DataStorage;
   }
   else
   {
     return nullptr;
   }
 }
 
 void QmitkSlicesInterpolator::Initialize(mitk::ToolManager *toolManager,
                                          const QList<mitk::SliceNavigationController *> &controllers)
 {
   Q_ASSERT(!controllers.empty());
 
   if (m_Initialized)
   {
     // remove old observers
     Uninitialize();
   }
 
   m_ToolManager = toolManager;
 
   if (m_ToolManager)
   {
     // set enabled only if a segmentation is selected
     mitk::DataNode *node = m_ToolManager->GetWorkingData(0);
     QWidget::setEnabled(node != nullptr);
 
     // react whenever the set of selected segmentation changes
     m_ToolManager->WorkingDataChanged +=
       mitk::MessageDelegate<QmitkSlicesInterpolator>(this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified);
     m_ToolManager->ReferenceDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>(
       this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified);
 
     // connect to the slice navigation controller. after each change, call the interpolator
     foreach (mitk::SliceNavigationController *slicer, controllers)
     {
       // Has to be initialized
       m_LastSNC = slicer;
       m_TimePoints.insert(slicer, slicer->GetSelectedTimePoint());
 
       itk::MemberCommand<QmitkSlicesInterpolator>::Pointer deleteCommand =
         itk::MemberCommand<QmitkSlicesInterpolator>::New();
       deleteCommand->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnSliceNavigationControllerDeleted);
       m_ControllerToDeleteObserverTag.insert(slicer, slicer->AddObserver(itk::DeleteEvent(), deleteCommand));
 
       itk::MemberCommand<QmitkSlicesInterpolator>::Pointer timeChangedCommand =
         itk::MemberCommand<QmitkSlicesInterpolator>::New();
       timeChangedCommand->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnTimeChanged);
       m_ControllerToTimeObserverTag.insert(
         slicer, slicer->AddObserver(mitk::SliceNavigationController::TimeGeometryEvent(nullptr, 0), timeChangedCommand));
 
       itk::MemberCommand<QmitkSlicesInterpolator>::Pointer sliceChangedCommand =
         itk::MemberCommand<QmitkSlicesInterpolator>::New();
       sliceChangedCommand->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnSliceChanged);
       m_ControllerToSliceObserverTag.insert(
         slicer, slicer->AddObserver(mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), sliceChangedCommand));
     }
     ACTION_TO_SLICEDIMENSION = createActionToSliceDimension();
   }
 
   m_Initialized = true;
 }
 
 void QmitkSlicesInterpolator::Uninitialize()
 {
   if (m_ToolManager.IsNotNull())
   {
     m_ToolManager->WorkingDataChanged -=
       mitk::MessageDelegate<QmitkSlicesInterpolator>(this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified);
     m_ToolManager->ReferenceDataChanged -= mitk::MessageDelegate<QmitkSlicesInterpolator>(
       this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified);
   }
 
   foreach (mitk::SliceNavigationController *slicer, m_ControllerToSliceObserverTag.keys())
   {
     slicer->RemoveObserver(m_ControllerToDeleteObserverTag.take(slicer));
     slicer->RemoveObserver(m_ControllerToTimeObserverTag.take(slicer));
     slicer->RemoveObserver(m_ControllerToSliceObserverTag.take(slicer));
   }
 
   ACTION_TO_SLICEDIMENSION.clear();
 
   m_ToolManager = nullptr;
 
   m_Initialized = false;
 }
 
 QmitkSlicesInterpolator::~QmitkSlicesInterpolator()
 {
   if (m_Initialized)
   {
     // remove old observers
     Uninitialize();
   }
 
   WaitForFutures();
 
   if (m_DataStorage.IsNotNull())
   {
     m_DataStorage->RemoveNodeEvent.RemoveListener(
       mitk::MessageDelegate1<QmitkSlicesInterpolator, const mitk::DataNode*>(this, &QmitkSlicesInterpolator::NodeRemoved)
     );
     if (m_DataStorage->Exists(m_3DContourNode))
       m_DataStorage->Remove(m_3DContourNode);
     if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
       m_DataStorage->Remove(m_InterpolatedSurfaceNode);
   }
 
   // remove observer
   m_Interpolator->RemoveObserver(InterpolationAbortedObserverTag);
   m_Interpolator->RemoveObserver(InterpolationInfoChangedObserverTag);
   m_SurfaceInterpolator->RemoveObserver(SurfaceInterpolationInfoChangedObserverTag);
 
   delete m_Timer;
 }
 
 /**
 External enableization...
 */
 void QmitkSlicesInterpolator::setEnabled(bool enable)
 {
   QWidget::setEnabled(enable);
 
   // Set the gui elements of the different interpolation modi enabled
   if (enable)
   {
     if (m_2DInterpolationEnabled)
     {
       this->Show2DInterpolationControls(true);
       m_Interpolator->Activate2DInterpolation(true);
     }
     else if (m_3DInterpolationEnabled)
     {
       this->Show3DInterpolationControls(true);
       this->Show3DInterpolationResult(true);
     }
   }
   // Set all gui elements of the interpolation disabled
   else
   {
     this->HideAllInterpolationControls();
     this->Show3DInterpolationResult(false);
   }
 }
 
 void QmitkSlicesInterpolator::On2DInterpolationEnabled(bool status)
 {
   OnInterpolationActivated(status);
   m_Interpolator->Activate2DInterpolation(status);
 }
 
 void QmitkSlicesInterpolator::On3DInterpolationEnabled(bool status)
 {
   On3DInterpolationActivated(status);
 }
 
 void QmitkSlicesInterpolator::OnInterpolationDisabled(bool status)
 {
   if (status)
   {
     OnInterpolationActivated(!status);
     On3DInterpolationActivated(!status);
     this->Show3DInterpolationResult(false);
   }
 }
 
 void QmitkSlicesInterpolator::HideAllInterpolationControls()
 {
   this->Show2DInterpolationControls(false);
   this->Show3DInterpolationControls(false);
 }
 
 void QmitkSlicesInterpolator::Show2DInterpolationControls(bool show)
 {
   m_BtnApply2D->setVisible(show);
   m_BtnApplyForAllSlices2D->setVisible(show);
 }
 
 void QmitkSlicesInterpolator::Show3DInterpolationControls(bool show)
 {
   m_BtnApply3D->setVisible(show);
 
   // T28261
   // m_BtnSuggestPlane->setVisible(show);
 
   m_ChkShowPositionNodes->setVisible(show);
   m_BtnReinit3DInterpolation->setVisible(show);
 }
 
 void QmitkSlicesInterpolator::OnInterpolationMethodChanged(int index)
 {
   switch (index)
   {
     case 0: // Disabled
       m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation");
       this->HideAllInterpolationControls();
       this->OnInterpolationActivated(false);
       this->On3DInterpolationActivated(false);
       this->Show3DInterpolationResult(false);
       m_Interpolator->Activate2DInterpolation(false);
       break;
 
     case 1: // 2D
       m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation (Enabled)");
       this->HideAllInterpolationControls();
       this->Show2DInterpolationControls(true);
       this->OnInterpolationActivated(true);
       this->On3DInterpolationActivated(false);
       m_Interpolator->Activate2DInterpolation(true);
       break;
 
     case 2: // 3D
       m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation (Enabled)");
       this->HideAllInterpolationControls();
       this->Show3DInterpolationControls(true);
       this->OnInterpolationActivated(false);
       this->On3DInterpolationActivated(true);
       m_Interpolator->Activate2DInterpolation(false);
       break;
 
     default:
       MITK_ERROR << "Unknown interpolation method!";
       m_CmbInterpolation->setCurrentIndex(0);
       break;
   }
 }
 
 void QmitkSlicesInterpolator::OnShowMarkers(bool state)
 {
   mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers =
     m_DataStorage->GetSubset(mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
 
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End();
        ++it)
   {
     it->Value()->SetProperty("helper object", mitk::BoolProperty::New(!state));
   }
 }
 
 void QmitkSlicesInterpolator::OnToolManagerWorkingDataModified()
 {
   if (m_ToolManager->GetWorkingData(0) != nullptr)
   {
     m_Segmentation = dynamic_cast<mitk::Image *>(m_ToolManager->GetWorkingData(0)->GetData());
     m_BtnReinit3DInterpolation->setEnabled(true);
   }
   else
   {
     // If no workingdata is set, remove the interpolation feedback
     this->GetDataStorage()->Remove(m_FeedbackNode);
     m_FeedbackNode->SetData(nullptr);
     this->GetDataStorage()->Remove(m_3DContourNode);
     m_3DContourNode->SetData(nullptr);
     this->GetDataStorage()->Remove(m_InterpolatedSurfaceNode);
     m_InterpolatedSurfaceNode->SetData(nullptr);
     m_BtnReinit3DInterpolation->setEnabled(false);
     return;
   }
   // Updating the current selected segmentation for the 3D interpolation
   SetCurrentContourListID();
 
   if (m_2DInterpolationEnabled)
   {
     OnInterpolationActivated(true); // re-initialize if needed
   }
   this->CheckSupportedImageDimension();
 }
 
 void QmitkSlicesInterpolator::OnToolManagerReferenceDataModified()
 {
 }
 
 void QmitkSlicesInterpolator::OnTimeChanged(itk::Object *sender, const itk::EventObject &e)
 {
   // Check if we really have a GeometryTimeEvent
   if (!dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent *>(&e))
     return;
 
   mitk::SliceNavigationController *slicer = dynamic_cast<mitk::SliceNavigationController *>(sender);
   Q_ASSERT(slicer);
 
   const auto timePoint = slicer->GetSelectedTimePoint();
   m_TimePoints[slicer] = timePoint;
 
   m_SurfaceInterpolator->SetCurrentTimePoint(timePoint);
 
   if (m_LastSNC == slicer)
   {
     slicer->SendSlice(); // will trigger a new interpolation
   }
 }
 
 void QmitkSlicesInterpolator::OnSliceChanged(itk::Object *sender, const itk::EventObject &e)
 {
   // Check whether we really have a GeometrySliceEvent
   if (!dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent *>(&e))
     return;
 
   mitk::SliceNavigationController *slicer = dynamic_cast<mitk::SliceNavigationController *>(sender);
 
   if (TranslateAndInterpolateChangedSlice(e, slicer))
   {
     slicer->GetRenderer()->RequestUpdate();
   }
 }
 
 bool QmitkSlicesInterpolator::TranslateAndInterpolateChangedSlice(const itk::EventObject &e,
                                                                   mitk::SliceNavigationController *slicer)
 {
   if (!m_2DInterpolationEnabled)
     return false;
 
   try
   {
     const mitk::SliceNavigationController::GeometrySliceEvent &event =
       dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent &>(e);
 
     mitk::TimeGeometry *tsg = event.GetTimeGeometry();
     if (tsg && m_TimePoints.contains(slicer) && tsg->IsValidTimePoint(m_TimePoints[slicer]))
     {
       mitk::SlicedGeometry3D *slicedGeometry =
         dynamic_cast<mitk::SlicedGeometry3D *>(tsg->GetGeometryForTimePoint(m_TimePoints[slicer]).GetPointer());
       if (slicedGeometry)
       {
         m_LastSNC = slicer;
         mitk::PlaneGeometry *plane =
           dynamic_cast<mitk::PlaneGeometry *>(slicedGeometry->GetPlaneGeometry(event.GetPos()));
         if (plane)
           Interpolate(plane, m_TimePoints[slicer], slicer);
         return true;
       }
     }
   }
   catch (const std::bad_cast &)
   {
     return false; // so what
   }
 
   return false;
 }
 
 void QmitkSlicesInterpolator::Interpolate(mitk::PlaneGeometry *plane,
                                           mitk::TimePointType timePoint,
                                           mitk::SliceNavigationController *slicer)
 {
   if (m_ToolManager)
   {
     mitk::DataNode *node = m_ToolManager->GetWorkingData(0);
     if (node)
     {
       m_Segmentation = dynamic_cast<mitk::Image *>(node->GetData());
       if (m_Segmentation)
       {
         if (!m_Segmentation->GetTimeGeometry()->IsValidTimePoint(timePoint))
         {
           MITK_WARN << "Cannot interpolate segmentation. Passed time point is not within the time bounds of WorkingImage. Time point: " << timePoint;
           return;
         }
         const auto timeStep = m_Segmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
 
         int clickedSliceDimension(-1);
         int clickedSliceIndex(-1);
 
         // calculate real slice position, i.e. slice of the image
         mitk::SegTool2D::DetermineAffectedImageSlice(m_Segmentation, plane, clickedSliceDimension, clickedSliceIndex);
 
         mitk::Image::Pointer interpolation =
           m_Interpolator->Interpolate(clickedSliceDimension, clickedSliceIndex, plane, timeStep);
         m_FeedbackNode->SetData(interpolation);
 
         m_LastSNC = slicer;
         m_LastSliceIndex = clickedSliceIndex;
       }
     }
   }
 }
 
 void QmitkSlicesInterpolator::OnSurfaceInterpolationFinished()
 {
   mitk::Surface::Pointer interpolatedSurface = m_SurfaceInterpolator->GetInterpolationResult();
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
 
   if (interpolatedSurface.IsNotNull() && workingNode &&
       workingNode->IsVisible(
         mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2"))))
   {
     m_BtnApply3D->setEnabled(true);
 
     // T28261
     // m_BtnSuggestPlane->setEnabled(true);
 
     m_InterpolatedSurfaceNode->SetData(interpolatedSurface);
     m_3DContourNode->SetData(m_SurfaceInterpolator->GetContoursAsSurface());
 
     this->Show3DInterpolationResult(true);
 
     if (!m_DataStorage->Exists(m_InterpolatedSurfaceNode))
     {
       m_DataStorage->Add(m_InterpolatedSurfaceNode);
     }
     if (!m_DataStorage->Exists(m_3DContourNode))
     {
       m_DataStorage->Add(m_3DContourNode, workingNode);
     }
   }
   else if (interpolatedSurface.IsNull())
   {
     m_BtnApply3D->setEnabled(false);
 
     // T28261
     // m_BtnSuggestPlane->setEnabled(false);
 
     if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
     {
       this->Show3DInterpolationResult(false);
     }
   }
 
   m_BtnReinit3DInterpolation->setEnabled(true);
 
   foreach (mitk::SliceNavigationController *slicer, m_ControllerToTimeObserverTag.keys())
   {
     slicer->GetRenderer()->RequestUpdate();
   }
 }
 
 void QmitkSlicesInterpolator::OnAcceptInterpolationClicked()
 {
   if (m_Segmentation && m_FeedbackNode->GetData())
   {
     // Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
     // reslicer
     vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
     // Set slice as input
     mitk::Image::Pointer slice = dynamic_cast<mitk::Image *>(m_FeedbackNode->GetData());
     reslice->SetInputSlice(slice->GetSliceData()->GetVtkImageAccessor(slice)->GetVtkImageData());
     // set overwrite mode to true to write back to the image volume
     reslice->SetOverwriteMode(true);
     reslice->Modified();
 
     const auto timePoint = m_LastSNC->GetSelectedTimePoint();
     if (!m_Segmentation->GetTimeGeometry()->IsValidTimePoint(timePoint))
     {
       MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationController is not within the time bounds of segmentation. Time point: " << timePoint;
       return;
     }
 
     mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
     extractor->SetInput(m_Segmentation);
     const auto timeStep = m_Segmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
     extractor->SetTimeStep(timeStep);
     extractor->SetWorldGeometry(m_LastSNC->GetCurrentPlaneGeometry());
     extractor->SetVtkOutputRequest(true);
     extractor->SetResliceTransformByGeometry(m_Segmentation->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
 
     extractor->Modified();
     extractor->Update();
 
     // the image was modified within the pipeline, but not marked so
     m_Segmentation->Modified();
     m_Segmentation->GetVtkImageData()->Modified();
 
     m_FeedbackNode->SetData(nullptr);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSlicesInterpolator::AcceptAllInterpolations(mitk::SliceNavigationController *slicer)
 {
   /*
    * What exactly is done here:
    * 1. We create an empty diff image for the current segmentation
    * 2. All interpolated slices are written into the diff image
    * 3. Then the diffimage is applied to the original segmentation
    */
   if (m_Segmentation)
   {
     mitk::Image::Pointer segmentation3D = m_Segmentation;
     unsigned int timeStep = 0;
     const auto timePoint = slicer->GetSelectedTimePoint();
 
     if (4 == m_Segmentation->GetDimension())
     {
       const auto* geometry = m_Segmentation->GetTimeGeometry();
 
       if (!geometry->IsValidTimePoint(timePoint))
       {
         MITK_WARN << "Cannot accept all interpolations. Time point selected by passed SliceNavigationController is not within the time bounds of segmentation. Time point: " << timePoint;
         return;
       }
 
       timeStep = geometry->TimePointToTimeStep(timePoint);
 
       auto timeSelector = mitk::ImageTimeSelector::New();
       timeSelector->SetInput(m_Segmentation);
       timeSelector->SetTimeNr(timeStep);
       timeSelector->Update();
 
       segmentation3D = timeSelector->GetOutput();
     }
 
     // Create an empty diff image for the undo operation
     auto diffImage = mitk::Image::New();
     diffImage->Initialize(segmentation3D);
 
     // Create scope for ImageWriteAccessor so that the accessor is destroyed right after use
     {
       mitk::ImageWriteAccessor accessor(diffImage);
 
       // Set all pixels to zero
       auto pixelType = mitk::MakeScalarPixelType<mitk::Tool::DefaultSegmentationDataType>();
 
       // For legacy purpose support former pixel type of segmentations (before multilabel)
       if (itk::IOComponentEnum::UCHAR == m_Segmentation->GetImageDescriptor()->GetChannelDescriptor().GetPixelType().GetComponentType())
         pixelType = mitk::MakeScalarPixelType<unsigned char>();
 
       memset(accessor.GetData(), 0, pixelType.GetSize() * diffImage->GetDimension(0) * diffImage->GetDimension(1) * diffImage->GetDimension(2));
     }
 
     // Since we need to shift the plane it must be clone so that the original plane isn't altered
     auto slicedGeometry = m_Segmentation->GetSlicedGeometry();
     auto planeGeometry = slicer->GetCurrentPlaneGeometry()->Clone();
     int sliceDimension = -1;
     int sliceIndex = -1;
 
     mitk::SegTool2D::DetermineAffectedImageSlice(m_Segmentation, planeGeometry, sliceDimension, sliceIndex);
 
     const auto numSlices = m_Segmentation->GetDimension(sliceDimension);
     mitk::ProgressBar::GetInstance()->AddStepsToDo(numSlices);
 
     std::atomic_uint totalChangedSlices;
 
     // Reuse interpolation algorithm instance for each slice to cache boundary calculations
     auto algorithm = mitk::ShapeBasedInterpolationAlgorithm::New();
 
     // Distribute slice interpolations to multiple threads
     const auto numThreads = std::min(std::thread::hardware_concurrency(), numSlices);
     std::vector<std::vector<unsigned int>> sliceIndices(numThreads);
 
     for (std::remove_const_t<decltype(numSlices)> sliceIndex = 0; sliceIndex < numSlices; ++sliceIndex)
       sliceIndices[sliceIndex % numThreads].push_back(sliceIndex);
 
     std::vector<std::thread> threads;
     threads.reserve(numThreads);
 
     // This lambda will be executed by the threads
     auto interpolate = [=, &interpolator = m_Interpolator, &totalChangedSlices](unsigned int threadIndex)
     {
       auto clonedPlaneGeometry = planeGeometry->Clone();
       auto origin = clonedPlaneGeometry->GetOrigin();
 
       for (auto sliceIndex : sliceIndices[threadIndex])
       {
         slicedGeometry->WorldToIndex(origin, origin);
         origin[sliceDimension] = sliceIndex;
         slicedGeometry->IndexToWorld(origin, origin);
         clonedPlaneGeometry->SetOrigin(origin);
 
         auto interpolation = interpolator->Interpolate(sliceDimension, sliceIndex, clonedPlaneGeometry, timeStep, algorithm);
 
         if (interpolation.IsNotNull())
         {
           // Setting up the reslicing pipeline which allows us to write the interpolation results back into the image volume
           auto reslicer = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
           // Set overwrite mode to true to write back to the image volume
           reslicer->SetInputSlice(interpolation->GetSliceData()->GetVtkImageAccessor(interpolation)->GetVtkImageData());
           reslicer->SetOverwriteMode(true);
           reslicer->Modified();
 
           auto diffSliceWriter = mitk::ExtractSliceFilter::New(reslicer);
 
           diffSliceWriter->SetInput(diffImage);
           diffSliceWriter->SetTimeStep(0);
           diffSliceWriter->SetWorldGeometry(clonedPlaneGeometry);
           diffSliceWriter->SetVtkOutputRequest(true);
           diffSliceWriter->SetResliceTransformByGeometry(diffImage->GetTimeGeometry()->GetGeometryForTimeStep(0));
           diffSliceWriter->Modified();
           diffSliceWriter->Update();
 
           ++totalChangedSlices;
         }
 
         mitk::ProgressBar::GetInstance()->Progress();
       }
     };
 
     m_Interpolator->EnableSliceImageCache();
 
     for (std::remove_const_t<decltype(numThreads)> threadIndex = 0; threadIndex < numThreads; ++threadIndex)
       threads.emplace_back(interpolate, threadIndex); // Run the interpolation
 
     for (auto& thread : threads)
       thread.join();
 
     m_Interpolator->DisableSliceImageCache();
 
     if (totalChangedSlices > 0)
     {
       // Create do/undo operations
       auto* doOp = new mitk::ApplyDiffImageOperation(mitk::OpTEST, m_Segmentation, diffImage, timeStep);
 
       auto* undoOp = new mitk::ApplyDiffImageOperation(mitk::OpTEST, m_Segmentation, diffImage, timeStep);
       undoOp->SetFactor(-1.0);
 
       auto comment = "Confirm all interpolations (" + std::to_string(totalChangedSlices) + ")";
 
       auto* undoStackItem = new mitk::OperationEvent(mitk::DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, comment);
 
       mitk::OperationEvent::IncCurrGroupEventId();
       mitk::OperationEvent::IncCurrObjectEventId();
       mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
 
       // Apply the changes to the original image
       mitk::DiffImageApplier::GetInstanceForUndo()->ExecuteOperation(doOp);
     }
 
     m_FeedbackNode->SetData(nullptr);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSlicesInterpolator::FinishInterpolation(mitk::SliceNavigationController *slicer)
 {
   // this redirect is for calling from outside
 
   if (slicer == nullptr)
     OnAcceptAllInterpolationsClicked();
   else
     AcceptAllInterpolations(slicer);
 }
 
 void QmitkSlicesInterpolator::OnAcceptAllInterpolationsClicked()
 {
   QMenu orientationPopup(this);
   std::map<QAction *, mitk::SliceNavigationController *>::const_iterator it;
   for (it = ACTION_TO_SLICEDIMENSION.begin(); it != ACTION_TO_SLICEDIMENSION.end(); it++)
     orientationPopup.addAction(it->first);
 
   connect(&orientationPopup, SIGNAL(triggered(QAction *)), this, SLOT(OnAcceptAllPopupActivated(QAction *)));
 
   orientationPopup.exec(QCursor::pos());
 }
 
 void QmitkSlicesInterpolator::OnAccept3DInterpolationClicked()
 {
   auto referenceImage = GetData<mitk::Image>(m_ToolManager->GetReferenceData(0));
 
   auto* segmentationDataNode = m_ToolManager->GetWorkingData(0);
   auto segmentation = GetData<mitk::Image>(segmentationDataNode);
 
   if (referenceImage.IsNull() || segmentation.IsNull())
     return;
 
   const auto* segmentationGeometry = segmentation->GetTimeGeometry();
   const auto timePoint = m_LastSNC->GetSelectedTimePoint();
 
   if (!referenceImage->GetTimeGeometry()->IsValidTimePoint(timePoint) ||
       !segmentationGeometry->IsValidTimePoint(timePoint))
   {
     MITK_WARN << "Cannot accept interpolation. Current time point is not within the time bounds of the patient image and segmentation.";
     return;
   }
 
   auto interpolatedSurface = GetData<mitk::Surface>(m_InterpolatedSurfaceNode);
 
   if (interpolatedSurface.IsNull())
     return;
 
   auto surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
 
   surfaceToImageFilter->SetImage(referenceImage);
   surfaceToImageFilter->SetMakeOutputBinary(true);
   surfaceToImageFilter->SetUShortBinaryPixelType(itk::IOComponentEnum::USHORT == segmentation->GetPixelType().GetComponentType());
   surfaceToImageFilter->SetInput(interpolatedSurface);
   surfaceToImageFilter->Update();
 
   mitk::Image::Pointer interpolatedSegmentation = surfaceToImageFilter->GetOutput();
 
   auto timeStep = interpolatedSegmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
   mitk::ImageReadAccessor readAccessor(interpolatedSegmentation, interpolatedSegmentation->GetVolumeData(timeStep));
   const auto* dataPointer = readAccessor.GetData();
 
   if (nullptr == dataPointer)
     return;
 
   timeStep = segmentationGeometry->TimePointToTimeStep(timePoint);
   segmentation->SetVolume(dataPointer, timeStep, 0);
 
   m_CmbInterpolation->setCurrentIndex(0);
   this->Show3DInterpolationResult(false);
 
   std::string name = segmentationDataNode->GetName() + "_3D-interpolation";
   mitk::TimeBounds timeBounds;
 
   if (1 < interpolatedSurface->GetTimeSteps())
   {
     name += "_t" + std::to_string(timeStep);
 
     auto* polyData = vtkPolyData::New();
     polyData->DeepCopy(interpolatedSurface->GetVtkPolyData(timeStep));
 
     auto surface = mitk::Surface::New();
     surface->SetVtkPolyData(polyData);
 
     interpolatedSurface = surface;
     timeBounds = segmentationGeometry->GetTimeBounds(timeStep);
   }
   else
   {
     timeBounds = segmentationGeometry->GetTimeBounds(0);
   }
 
   auto* surfaceGeometry = static_cast<mitk::ProportionalTimeGeometry*>(interpolatedSurface->GetTimeGeometry());
   surfaceGeometry->SetFirstTimePoint(timeBounds[0]);
   surfaceGeometry->SetStepDuration(timeBounds[1] - timeBounds[0]);
 
   // Typical file formats for surfaces do not save any time-related information. As a workaround at least for MITK scene files, we have the
   // possibility to seralize this information as properties.
 
   interpolatedSurface->SetProperty("ProportionalTimeGeometry.FirstTimePoint", mitk::FloatProperty::New(surfaceGeometry->GetFirstTimePoint()));
   interpolatedSurface->SetProperty("ProportionalTimeGeometry.StepDuration", mitk::FloatProperty::New(surfaceGeometry->GetStepDuration()));
 
   auto interpolatedSurfaceDataNode = mitk::DataNode::New();
 
   interpolatedSurfaceDataNode->SetData(interpolatedSurface);
   interpolatedSurfaceDataNode->SetName(name);
   interpolatedSurfaceDataNode->SetOpacity(0.7f);
 
   std::array<float, 3> rgb;
   segmentationDataNode->GetColor(rgb.data());
   interpolatedSurfaceDataNode->SetColor(rgb.data());
 
   m_DataStorage->Add(interpolatedSurfaceDataNode, segmentationDataNode);
 }
 
 void ::QmitkSlicesInterpolator::OnSuggestPlaneClicked()
 {
   if (m_PlaneWatcher.isRunning())
     m_PlaneWatcher.waitForFinished();
   m_PlaneFuture = QtConcurrent::run(this, &QmitkSlicesInterpolator::RunPlaneSuggestion);
   m_PlaneWatcher.setFuture(m_PlaneFuture);
 }
 
 void ::QmitkSlicesInterpolator::RunPlaneSuggestion()
 {
   if (m_FirstRun)
     mitk::ProgressBar::GetInstance()->AddStepsToDo(7);
   else
     mitk::ProgressBar::GetInstance()->AddStepsToDo(3);
 
   m_EdgeDetector->SetSegmentationMask(m_Segmentation);
   m_EdgeDetector->SetInput(dynamic_cast<mitk::Image *>(m_ToolManager->GetReferenceData(0)->GetData()));
   m_EdgeDetector->Update();
 
   mitk::UnstructuredGrid::Pointer uGrid = mitk::UnstructuredGrid::New();
   uGrid->SetVtkUnstructuredGrid(m_EdgeDetector->GetOutput()->GetVtkUnstructuredGrid());
 
   mitk::ProgressBar::GetInstance()->Progress();
 
   mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface *>(m_InterpolatedSurfaceNode->GetData());
 
   vtkSmartPointer<vtkPolyData> vtkpoly = surface->GetVtkPolyData();
   vtkSmartPointer<vtkPoints> vtkpoints = vtkpoly->GetPoints();
 
   vtkSmartPointer<vtkUnstructuredGrid> vGrid = vtkSmartPointer<vtkUnstructuredGrid>::New();
   vtkSmartPointer<vtkPolyVertex> verts = vtkSmartPointer<vtkPolyVertex>::New();
 
   verts->GetPointIds()->SetNumberOfIds(vtkpoints->GetNumberOfPoints());
   for (int i = 0; i < vtkpoints->GetNumberOfPoints(); i++)
   {
     verts->GetPointIds()->SetId(i, i);
   }
 
   vGrid->Allocate(1);
   vGrid->InsertNextCell(verts->GetCellType(), verts->GetPointIds());
   vGrid->SetPoints(vtkpoints);
 
   mitk::UnstructuredGrid::Pointer interpolationGrid = mitk::UnstructuredGrid::New();
   interpolationGrid->SetVtkUnstructuredGrid(vGrid);
 
   m_PointScorer->SetInput(0, uGrid);
   m_PointScorer->SetInput(1, interpolationGrid);
   m_PointScorer->Update();
 
   mitk::UnstructuredGrid::Pointer scoredGrid = mitk::UnstructuredGrid::New();
   scoredGrid = m_PointScorer->GetOutput();
 
   mitk::ProgressBar::GetInstance()->Progress();
 
   double spacing = mitk::SurfaceInterpolationController::GetInstance()->GetDistanceImageSpacing();
   mitk::UnstructuredGridClusteringFilter::Pointer clusterFilter = mitk::UnstructuredGridClusteringFilter::New();
   clusterFilter->SetInput(scoredGrid);
   clusterFilter->SetMeshing(false);
   clusterFilter->SetMinPts(4);
   clusterFilter->Seteps(spacing);
   clusterFilter->Update();
 
   mitk::ProgressBar::GetInstance()->Progress();
 
   // Create plane suggestion
   mitk::BaseRenderer::Pointer br =
     mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0"));
   mitk::PlaneProposer planeProposer;
   std::vector<mitk::UnstructuredGrid::Pointer> grids = clusterFilter->GetAllClusters();
 
   planeProposer.SetUnstructuredGrids(grids);
   mitk::SliceNavigationController::Pointer snc = br->GetSliceNavigationController();
   planeProposer.SetSliceNavigationController(snc);
   planeProposer.SetUseDistances(true);
   try
   {
     planeProposer.CreatePlaneInfo();
   }
   catch (const mitk::Exception &e)
   {
     MITK_ERROR << e.what();
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   m_FirstRun = false;
 }
 
 void QmitkSlicesInterpolator::OnReinit3DInterpolation()
 {
   mitk::NodePredicateProperty::Pointer pred =
     mitk::NodePredicateProperty::New("3DContourContainer", mitk::BoolProperty::New(true));
   mitk::DataStorage::SetOfObjects::ConstPointer contourNodes =
     m_DataStorage->GetDerivations(m_ToolManager->GetWorkingData(0), pred);
 
   if (contourNodes->Size() != 0)
   {
     m_BtnApply3D->setEnabled(true);
     m_3DContourNode = contourNodes->at(0);
     mitk::Surface::Pointer contours = dynamic_cast<mitk::Surface *>(m_3DContourNode->GetData());
     if (contours)
       mitk::SurfaceInterpolationController::GetInstance()->ReinitializeInterpolation(contours);
     m_BtnReinit3DInterpolation->setEnabled(false);
   }
   else
   {
     m_BtnApply3D->setEnabled(false);
     QMessageBox errorInfo;
     errorInfo.setWindowTitle("Reinitialize surface interpolation");
     errorInfo.setIcon(QMessageBox::Information);
     errorInfo.setText("No contours available for the selected segmentation!");
     errorInfo.exec();
   }
 }
 
 void QmitkSlicesInterpolator::OnAcceptAllPopupActivated(QAction *action)
 {
   try
   {
     std::map<QAction *, mitk::SliceNavigationController *>::const_iterator iter = ACTION_TO_SLICEDIMENSION.find(action);
     if (iter != ACTION_TO_SLICEDIMENSION.end())
     {
       mitk::SliceNavigationController *slicer = iter->second;
       AcceptAllInterpolations(slicer);
     }
   }
   catch (...)
   {
     /* Showing message box with possible memory error */
     QMessageBox errorInfo;
     errorInfo.setWindowTitle("Interpolation Process");
     errorInfo.setIcon(QMessageBox::Critical);
     errorInfo.setText("An error occurred during interpolation. Possible cause: Not enough memory!");
     errorInfo.exec();
 
     // additional error message on std::cerr
     std::cerr << "Ill construction in " __FILE__ " l. " << __LINE__ << std::endl;
   }
 }
 
 void QmitkSlicesInterpolator::OnInterpolationActivated(bool on)
 {
   m_2DInterpolationEnabled = on;
 
   try
   {
     if (m_DataStorage.IsNotNull())
     {
       if (on && !m_DataStorage->Exists(m_FeedbackNode))
       {
         m_DataStorage->Add(m_FeedbackNode);
       }
     }
   }
   catch (...)
   {
     // don't care (double add/remove)
   }
 
   if (m_ToolManager)
   {
     mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
     mitk::DataNode *referenceNode = m_ToolManager->GetReferenceData(0);
     QWidget::setEnabled(workingNode != nullptr);
 
     m_BtnApply2D->setEnabled(on);
     m_FeedbackNode->SetVisibility(on);
 
     if (!on)
     {
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       return;
     }
 
     if (workingNode)
     {
       mitk::Image *segmentation = dynamic_cast<mitk::Image *>(workingNode->GetData());
       if (segmentation)
       {
         m_Interpolator->SetSegmentationVolume(segmentation);
 
         if (referenceNode)
         {
           mitk::Image *referenceImage = dynamic_cast<mitk::Image *>(referenceNode->GetData());
           m_Interpolator->SetReferenceVolume(referenceImage); // may be nullptr
         }
       }
     }
   }
 
   UpdateVisibleSuggestion();
 }
 
 void QmitkSlicesInterpolator::Run3DInterpolation()
 {
   m_SurfaceInterpolator->Interpolate();
 }
 
 void QmitkSlicesInterpolator::StartUpdateInterpolationTimer()
 {
   m_Timer->start(500);
 }
 
 void QmitkSlicesInterpolator::StopUpdateInterpolationTimer()
 {
   m_Timer->stop();
   m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(SURFACE_COLOR_RGB));
   mitk::RenderingManager::GetInstance()->RequestUpdate(
     mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3"))->GetRenderWindow());
 }
 
 void QmitkSlicesInterpolator::ChangeSurfaceColor()
 {
   float currentColor[3];
   m_InterpolatedSurfaceNode->GetColor(currentColor);
 
   if (currentColor[2] == SURFACE_COLOR_RGB[2])
   {
     m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 1.0f));
   }
   else
   {
     m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(SURFACE_COLOR_RGB));
   }
   m_InterpolatedSurfaceNode->Update();
   mitk::RenderingManager::GetInstance()->RequestUpdate(
     mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3"))->GetRenderWindow());
 }
 
 void QmitkSlicesInterpolator::On3DInterpolationActivated(bool on)
 {
   m_3DInterpolationEnabled = on;
 
   this->CheckSupportedImageDimension();
   try
   {
     if (m_DataStorage.IsNotNull() && m_ToolManager && m_3DInterpolationEnabled)
     {
       mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
 
       if (workingNode)
       {
         if ((workingNode->IsVisible(mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")))))
         {
           int ret = QMessageBox::Yes;
 
           if (m_SurfaceInterpolator->EstimatePortionOfNeededMemory() > 0.5)
           {
             QMessageBox msgBox;
             msgBox.setText("Due to short handed system memory the 3D interpolation may be very slow!");
             msgBox.setInformativeText("Are you sure you want to activate the 3D interpolation?");
             msgBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
             ret = msgBox.exec();
           }
 
           if (m_Watcher.isRunning())
             m_Watcher.waitForFinished();
 
           if (ret == QMessageBox::Yes)
           {
             m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
             m_Watcher.setFuture(m_Future);
           }
           else
           {
             m_CmbInterpolation->setCurrentIndex(0);
           }
         }
       }
       else
       {
         QWidget::setEnabled(false);
         m_ChkShowPositionNodes->setEnabled(m_3DInterpolationEnabled);
       }
     }
     if (!m_3DInterpolationEnabled)
     {
       this->Show3DInterpolationResult(false);
       m_BtnApply3D->setEnabled(m_3DInterpolationEnabled);
 
       // T28261
       // m_BtnSuggestPlane->setEnabled(m_3DInterpolationEnabled);
     }
   }
   catch (...)
   {
     MITK_ERROR << "Error with 3D surface interpolation!";
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSlicesInterpolator::EnableInterpolation(bool on)
 {
   // only to be called from the outside world
   // just a redirection to OnInterpolationActivated
   OnInterpolationActivated(on);
 }
 
 void QmitkSlicesInterpolator::Enable3DInterpolation(bool on)
 {
   // only to be called from the outside world
   // just a redirection to OnInterpolationActivated
   On3DInterpolationActivated(on);
 }
 
 void QmitkSlicesInterpolator::UpdateVisibleSuggestion()
 {
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSlicesInterpolator::OnInterpolationInfoChanged(const itk::EventObject & /*e*/)
 {
   // something (e.g. undo) changed the interpolation info, we should refresh our display
   UpdateVisibleSuggestion();
 }
 
 void QmitkSlicesInterpolator::OnInterpolationAborted(const itk::EventObject& /*e*/)
 {
   m_CmbInterpolation->setCurrentIndex(0);
   m_FeedbackNode->SetData(nullptr);
 }
 
 void QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged(const itk::EventObject & /*e*/)
 {
   if (m_3DInterpolationEnabled)
   {
     if (m_Watcher.isRunning())
       m_Watcher.waitForFinished();
     m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
     m_Watcher.setFuture(m_Future);
   }
 }
 
 void QmitkSlicesInterpolator::SetCurrentContourListID()
 {
   // New ContourList = hide current interpolation
   Show3DInterpolationResult(false);
 
   if (m_DataStorage.IsNotNull() && m_ToolManager && m_LastSNC)
   {
     mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
 
     if (workingNode)
     {
       QWidget::setEnabled(true);
 
       const auto timePoint = m_LastSNC->GetSelectedTimePoint();
       // In case the time is not valid use 0 to access the time geometry of the working node
       unsigned int time_position = 0;
       if (!workingNode->GetData()->GetTimeGeometry()->IsValidTimePoint(timePoint))
       {
         MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationController is not within the time bounds of WorkingImage. Time point: " << timePoint;
         return;
       }
       time_position = workingNode->GetData()->GetTimeGeometry()->TimePointToTimeStep(timePoint);
 
       mitk::Vector3D spacing = workingNode->GetData()->GetGeometry(time_position)->GetSpacing();
       double minSpacing(100);
       double maxSpacing(0);
       for (int i = 0; i < 3; i++)
       {
         if (spacing[i] < minSpacing)
         {
           minSpacing = spacing[i];
         }
         if (spacing[i] > maxSpacing)
         {
           maxSpacing = spacing[i];
         }
       }
 
       m_SurfaceInterpolator->SetMaxSpacing(maxSpacing);
       m_SurfaceInterpolator->SetMinSpacing(minSpacing);
       m_SurfaceInterpolator->SetDistanceImageVolume(50000);
 
       mitk::Image *segmentationImage = dynamic_cast<mitk::Image *>(workingNode->GetData());
 
       m_SurfaceInterpolator->SetCurrentInterpolationSession(segmentationImage);
       m_SurfaceInterpolator->SetCurrentTimePoint(timePoint);
 
       if (m_3DInterpolationEnabled)
       {
         if (m_Watcher.isRunning())
           m_Watcher.waitForFinished();
         m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
         m_Watcher.setFuture(m_Future);
       }
     }
     else
     {
       QWidget::setEnabled(false);
     }
   }
 }
 
 void QmitkSlicesInterpolator::Show3DInterpolationResult(bool status)
 {
   if (m_InterpolatedSurfaceNode.IsNotNull())
     m_InterpolatedSurfaceNode->SetVisibility(status);
 
   if (m_3DContourNode.IsNotNull())
     m_3DContourNode->SetVisibility(
       status, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSlicesInterpolator::CheckSupportedImageDimension()
 {
   if (m_ToolManager->GetWorkingData(0))
     m_Segmentation = dynamic_cast<mitk::Image *>(m_ToolManager->GetWorkingData(0)->GetData());
 
   /*if (m_3DInterpolationEnabled && m_Segmentation && m_Segmentation->GetDimension() != 3)
   {
     QMessageBox info;
     info.setWindowTitle("3D Interpolation Process");
     info.setIcon(QMessageBox::Information);
     info.setText("3D Interpolation is only supported for 3D images at the moment!");
     info.exec();
     m_CmbInterpolation->setCurrentIndex(0);
   }*/
 }
 
 void QmitkSlicesInterpolator::OnSliceNavigationControllerDeleted(const itk::Object *sender,
                                                                  const itk::EventObject & /*e*/)
 {
   // Don't know how to avoid const_cast here?!
   mitk::SliceNavigationController *slicer =
     dynamic_cast<mitk::SliceNavigationController *>(const_cast<itk::Object *>(sender));
   if (slicer)
   {
     m_ControllerToTimeObserverTag.remove(slicer);
     m_ControllerToSliceObserverTag.remove(slicer);
     m_ControllerToDeleteObserverTag.remove(slicer);
   }
 }
 
 void QmitkSlicesInterpolator::WaitForFutures()
 {
   if (m_Watcher.isRunning())
   {
     m_Watcher.waitForFinished();
   }
 
   if (m_PlaneWatcher.isRunning())
   {
     m_PlaneWatcher.waitForFinished();
   }
 }
 
 void QmitkSlicesInterpolator::NodeRemoved(const mitk::DataNode* node)
 {
   if ((m_ToolManager && m_ToolManager->GetWorkingData(0) == node) ||
       node == m_3DContourNode ||
       node == m_FeedbackNode ||
       node == m_InterpolatedSurfaceNode)
   {
     WaitForFutures();
   }
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkStaticDynamicSegmentationDialog.cpp b/Modules/SegmentationUI/Qmitk/QmitkStaticDynamicSegmentationDialog.cpp
new file mode 100644
index 0000000000..280a3b5107
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkStaticDynamicSegmentationDialog.cpp
@@ -0,0 +1,75 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "QmitkStaticDynamicSegmentationDialog.h"
+
+#include <mitkImageTimeSelector.h>
+#include <mitkRenderingManager.h>
+#include <mitkSliceNavigationController.h>
+
+#include <QPushButton>
+
+QmitkStaticDynamicSegmentationDialog::QmitkStaticDynamicSegmentationDialog(QWidget *parent)
+  : QMessageBox(parent)
+{
+  this->setWindowModality(Qt::WindowModality::NonModal);
+  this->setIcon(QMessageBox::Question);
+  this->setWindowTitle(tr("Create a static or dynamic segmentation?"));
+  this->setText(tr("The selected image has multiple time steps."));
+  this->setInformativeText(tr("Do you want to create a static "
+    "segmentation that is identical for all time steps or do you want to create a "
+    "dynamic segmentation to segment individual time steps?"));
+
+  QAbstractButton* staticButton = this->addButton(tr("Create static segmentation"), QMessageBox::AcceptRole);
+  this->addButton(tr("Create dynamic segmentation"), QMessageBox::AcceptRole);
+
+  // only the static button needs to be connected to take care of the special case, where
+  // the time steps of the 4D image are combined into a single time step of the 3D segmentation.
+  connect(staticButton, &QAbstractButton::clicked, this, &QmitkStaticDynamicSegmentationDialog::OnStaticButtonClicked);
+}
+
+void QmitkStaticDynamicSegmentationDialog::SetReferenceImage(const mitk::Image* referenceImage)
+{
+  m_ReferenceImage = referenceImage;
+  m_SegmentationTemplate = referenceImage;
+
+  const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
+  m_ImageTimeStep = 0;
+  if (m_ReferenceImage->GetTimeGeometry()->IsValidTimePoint(currentTimePoint))
+  {
+    m_ImageTimeStep = m_ReferenceImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
+  }
+}
+
+mitk::Image::ConstPointer QmitkStaticDynamicSegmentationDialog::GetSegmentationTemplate() const
+{
+  return m_SegmentationTemplate;
+}
+
+void QmitkStaticDynamicSegmentationDialog::OnStaticButtonClicked(bool /*checked*/)
+{
+  auto selector = mitk::ImageTimeSelector::New();
+  selector->SetInput(m_ReferenceImage);
+  selector->SetTimeNr(m_ImageTimeStep);
+  selector->Update();
+  mitk::Image::Pointer newImage = selector->GetOutput();
+
+  const auto referenceTimeGeometry = m_ReferenceImage->GetTimeGeometry();
+  auto timeGeometry = mitk::ProportionalTimeGeometry::New();
+  timeGeometry->SetFirstTimePoint(referenceTimeGeometry->GetMinimumTimePoint());
+  timeGeometry->SetStepDuration(referenceTimeGeometry->GetMaximumTimePoint() - referenceTimeGeometry->GetMinimumTimePoint());
+  timeGeometry->SetTimeStepGeometry(m_ReferenceImage->GetGeometry(m_ImageTimeStep), 0);
+
+  newImage->SetTimeGeometry(timeGeometry);
+
+  m_SegmentationTemplate = newImage;
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkStaticDynamicSegmentationDialog.h b/Modules/SegmentationUI/Qmitk/QmitkStaticDynamicSegmentationDialog.h
new file mode 100644
index 0000000000..28b933cf59
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitkStaticDynamicSegmentationDialog.h
@@ -0,0 +1,53 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#ifndef QMITKSTATICDYNAMICSEGMENTATIONDIALOG_H
+#define QMITKSTATICDYNAMICSEGMENTATIONDIALOG_H
+
+#include <MitkSegmentationUIExports.h>
+
+#include <QMessageBox>
+
+#include <mitkImage.h>
+
+/**
+ * \brief Dialog for static / dynamic segmentation node creation.
+ *
+ * This dialog is used to ask a user about the dimensionality of a newly created segmentation.
+ * If the user wants to create a static / 3D segmentation image from a given 4D reference image,
+ * the time steps of the reference image are combined into a single time step, with a step duration
+ * that is as long as the step duration of all 4D time steps combined.
+ */
+class MITKSEGMENTATIONUI_EXPORT QmitkStaticDynamicSegmentationDialog : public QMessageBox
+{
+  Q_OBJECT
+
+public:
+
+  QmitkStaticDynamicSegmentationDialog(QWidget* parent = nullptr);
+
+  void SetReferenceImage(const mitk::Image* referenceImage);
+  mitk::Image::ConstPointer GetSegmentationTemplate() const;
+  
+private Q_SLOTS:
+
+  void OnStaticButtonClicked(bool checked = false);
+
+private:
+
+  mitk::Image::ConstPointer m_SegmentationTemplate;
+  const mitk::Image* m_ReferenceImage;
+  unsigned int m_ImageTimeStep = 0;
+
+};
+
+#endif // QMITKSTATICDYNAMICSEGMENTATIONDIALOG_H
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSurfaceBasedInterpolatorWidget.cpp b/Modules/SegmentationUI/Qmitk/QmitkSurfaceBasedInterpolatorWidget.cpp
index cba76244e0..8179d37041 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSurfaceBasedInterpolatorWidget.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSurfaceBasedInterpolatorWidget.cpp
@@ -1,355 +1,353 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkSurfaceBasedInterpolatorWidget.h"
 
 #include "mitkColorProperty.h"
 #include "mitkInteractionConst.h"
 #include "mitkOperationEvent.h"
 #include "mitkProgressBar.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkSegTool2D.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkSurfaceToImageFilter.h"
 #include "mitkUndoController.h"
 #include "mitkVtkRepresentationProperty.h"
 #include <mitkToolManagerProvider.h>
 
-#include "QmitkStdMultiWidget.h"
-
 #include <itkCommand.h>
 #include <vtkProperty.h>
 
 #include <QMessageBox>
 
 QmitkSurfaceBasedInterpolatorWidget::QmitkSurfaceBasedInterpolatorWidget(QWidget *parent, const char * /*name*/)
   : QWidget(parent),
     m_SurfaceBasedInterpolatorController(mitk::SurfaceBasedInterpolationController::GetInstance()),
     m_ToolManager(nullptr),
     m_Activated(false),
     m_DataStorage(nullptr)
 {
   m_Controls.setupUi(this);
 
-  m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
+  m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
 
   m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<QmitkSurfaceBasedInterpolatorWidget>(
     this, &QmitkSurfaceBasedInterpolatorWidget::OnToolManagerWorkingDataModified);
 
   connect(m_Controls.m_btStart, SIGNAL(toggled(bool)), this, SLOT(OnToggleWidgetActivation(bool)));
   connect(m_Controls.m_btAccept, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()));
   connect(m_Controls.m_cbShowPositionNodes, SIGNAL(toggled(bool)), this, SLOT(OnShowMarkers(bool)));
 
   itk::ReceptorMemberCommand<QmitkSurfaceBasedInterpolatorWidget>::Pointer command =
     itk::ReceptorMemberCommand<QmitkSurfaceBasedInterpolatorWidget>::New();
   command->SetCallbackFunction(this, &QmitkSurfaceBasedInterpolatorWidget::OnSurfaceInterpolationInfoChanged);
   m_SurfaceInterpolationInfoChangedObserverTag =
     m_SurfaceBasedInterpolatorController->AddObserver(itk::ModifiedEvent(), command);
 
   m_InterpolatedSurfaceNode = mitk::DataNode::New();
   m_InterpolatedSurfaceNode->SetName("Surface Interpolation feedback");
   m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0, 255.0, 0.0));
   m_InterpolatedSurfaceNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
   m_InterpolatedSurfaceNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_InterpolatedSurfaceNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_InterpolatedSurfaceNode->SetVisibility(false);
 
   m_3DContourNode = mitk::DataNode::New();
   m_3DContourNode->SetName("Drawn Contours");
   m_3DContourNode->SetProperty("color", mitk::ColorProperty::New(0.0, 0.0, 0.0));
   m_3DContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_3DContourNode->SetProperty("material.representation", mitk::VtkRepresentationProperty::New(VTK_WIREFRAME));
   m_3DContourNode->SetProperty("material.wireframeLineWidth", mitk::FloatProperty::New(2.0f));
   m_3DContourNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_3DContourNode->SetVisibility(
     false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0")));
   m_3DContourNode->SetVisibility(
     false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
   m_3DContourNode->SetVisibility(
     false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")));
   m_3DContourNode->SetVisibility(
     false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
 
   connect(&m_Watcher, SIGNAL(started()), this, SLOT(StartUpdateInterpolationTimer()));
   connect(&m_Watcher, SIGNAL(finished()), this, SLOT(OnSurfaceInterpolationFinished()));
   connect(&m_Watcher, SIGNAL(finished()), this, SLOT(StopUpdateInterpolationTimer()));
 
   m_Timer = new QTimer(this);
   connect(m_Timer, SIGNAL(timeout()), this, SLOT(ChangeSurfaceColor()));
 
   m_Controls.m_btAccept->setEnabled(false);
   m_Controls.m_cbShowPositionNodes->setEnabled(false);
 
   this->setEnabled(false);
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::SetDataStorage(mitk::DataStorage &storage)
 {
   m_DataStorage = &storage;
 }
 
 QmitkSurfaceBasedInterpolatorWidget::~QmitkSurfaceBasedInterpolatorWidget()
 {
   m_ToolManager->WorkingDataChanged -= mitk::MessageDelegate<QmitkSurfaceBasedInterpolatorWidget>(
     this, &QmitkSurfaceBasedInterpolatorWidget::OnToolManagerWorkingDataModified);
 
   if (m_DataStorage->Exists(m_3DContourNode))
     m_DataStorage->Remove(m_3DContourNode);
 
   if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
     m_DataStorage->Remove(m_InterpolatedSurfaceNode);
 
   // remove observer
   m_SurfaceBasedInterpolatorController->RemoveObserver(m_SurfaceInterpolationInfoChangedObserverTag);
 
   delete m_Timer;
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::ShowInterpolationResult(bool status)
 {
   if (m_InterpolatedSurfaceNode.IsNotNull())
     m_InterpolatedSurfaceNode->SetVisibility(status);
 
   if (m_3DContourNode.IsNotNull())
     m_3DContourNode->SetVisibility(
       status, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::OnSurfaceInterpolationFinished()
 {
   mitk::Surface::Pointer interpolatedSurface = m_SurfaceBasedInterpolatorController->GetInterpolationResult();
 
   if (interpolatedSurface.IsNotNull())
   {
     m_InterpolatedSurfaceNode->SetData(interpolatedSurface);
     m_3DContourNode->SetData(m_SurfaceBasedInterpolatorController->GetContoursAsSurface());
     this->ShowInterpolationResult(true);
   }
   else
   {
     m_InterpolatedSurfaceNode->SetData(nullptr);
     m_3DContourNode->SetData(nullptr);
     this->ShowInterpolationResult(false);
   }
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::OnShowMarkers(bool state)
 {
   mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers =
     m_DataStorage->GetSubset(mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
 
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End();
        ++it)
   {
     it->Value()->SetProperty("helper object", mitk::BoolProperty::New(!state));
   }
 
   mitk::SegTool2D::Pointer manualSegmentationTool;
 
   unsigned int numberOfExistingTools = m_ToolManager->GetTools().size();
 
   for (unsigned int i = 0; i < numberOfExistingTools; i++)
   {
     manualSegmentationTool = dynamic_cast<mitk::SegTool2D *>(m_ToolManager->GetToolById(i));
 
     if (manualSegmentationTool)
     {
       manualSegmentationTool->SetShowMarkerNodes(state);
     }
   }
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::StartUpdateInterpolationTimer()
 {
   m_Timer->start(500);
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::StopUpdateInterpolationTimer()
 {
   m_Timer->stop();
   m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0, 255.0, 0.0));
   mitk::RenderingManager::GetInstance()->RequestUpdate(
     mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3"))->GetRenderWindow());
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::ChangeSurfaceColor()
 {
   float currentColor[3];
   m_InterpolatedSurfaceNode->GetColor(currentColor);
 
   float yellow[3] = {255.0, 255.0, 0.0};
 
   if (currentColor[2] == yellow[2])
   {
     m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0, 255.0, 255.0));
   }
   else
   {
     m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(yellow));
   }
   m_InterpolatedSurfaceNode->Update();
   mitk::RenderingManager::GetInstance()->RequestUpdate(
     mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3"))->GetRenderWindow());
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::OnToolManagerWorkingDataModified()
 {
   mitk::DataNode *workingNode = this->m_ToolManager->GetWorkingData(0);
   if (!workingNode)
   {
     this->setEnabled(false);
     return;
   }
 
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
   // TODO adapt tool manager so that this check is done there, e.g. convenience function
   //  Q_ASSERT(workingImage);
   if (!workingImage)
   {
     this->setEnabled(false);
     return;
   }
 
   if (workingImage->GetDimension() > 4 || workingImage->GetDimension() < 3)
   {
     this->setEnabled(false);
     return;
   }
 
   m_WorkingImage = workingImage;
 
   this->setEnabled(true);
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::OnRunInterpolation()
 {
   m_SurfaceBasedInterpolatorController->Interpolate();
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::OnToggleWidgetActivation(bool enabled)
 {
   Q_ASSERT(m_ToolManager);
 
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   if (!workingNode)
     return;
 
   m_Controls.m_btAccept->setEnabled(enabled);
   m_Controls.m_cbShowPositionNodes->setEnabled(enabled);
 
   if (enabled)
     m_Controls.m_btStart->setText("Stop");
   else
     m_Controls.m_btStart->setText("Start");
 
   for (unsigned int i = 0; i < m_ToolManager->GetTools().size(); i++)
   {
     mitk::SegTool2D *tool = dynamic_cast<mitk::SegTool2D *>(m_ToolManager->GetToolById(i));
     if (tool)
       tool->SetEnable3DInterpolation(enabled);
   }
 
   if (enabled)
   {
     if (!m_DataStorage->Exists(m_InterpolatedSurfaceNode))
     {
       m_DataStorage->Add(m_InterpolatedSurfaceNode);
     }
 
     if (!m_DataStorage->Exists(m_3DContourNode))
     {
       m_DataStorage->Add(m_3DContourNode);
     }
 
     mitk::Vector3D spacing = m_WorkingImage->GetGeometry(0)->GetSpacing();
     double minSpacing(100);
     double maxSpacing(0);
     for (int i = 0; i < 3; i++)
     {
       if (spacing[i] < minSpacing)
       {
         minSpacing = spacing[i];
       }
       else if (spacing[i] > maxSpacing)
       {
         maxSpacing = spacing[i];
       }
     }
 
     m_SurfaceBasedInterpolatorController->SetWorkingImage(m_WorkingImage);
     m_SurfaceBasedInterpolatorController->SetActiveLabel(m_WorkingImage->GetActiveLabel()->GetValue());
     m_SurfaceBasedInterpolatorController->SetMaxSpacing(maxSpacing);
     m_SurfaceBasedInterpolatorController->SetMinSpacing(minSpacing);
     m_SurfaceBasedInterpolatorController->SetDistanceImageVolume(50000);
 
     int ret = QMessageBox::Yes;
 
     if (m_SurfaceBasedInterpolatorController->EstimatePortionOfNeededMemory() > 0.5)
     {
       QMessageBox msgBox;
       msgBox.setText("Due to short handed system memory the 3D interpolation may be very slow!");
       msgBox.setInformativeText("Are you sure you want to activate the 3D interpolation?");
       msgBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
       ret = msgBox.exec();
     }
 
     if (m_Watcher.isRunning())
       m_Watcher.waitForFinished();
 
     if (ret == QMessageBox::Yes)
     {
       m_Future = QtConcurrent::run(this, &QmitkSurfaceBasedInterpolatorWidget::OnRunInterpolation);
       m_Watcher.setFuture(m_Future);
     }
   }
   else
   {
     if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
     {
       m_DataStorage->Remove(m_InterpolatedSurfaceNode);
     }
     if (m_DataStorage->Exists(m_3DContourNode))
     {
       m_DataStorage->Remove(m_3DContourNode);
     }
 
     mitk::UndoController::GetCurrentUndoModel()->Clear();
   }
 
   m_Activated = enabled;
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::OnAcceptInterpolationClicked()
 {
   if (m_InterpolatedSurfaceNode.IsNotNull() && m_InterpolatedSurfaceNode->GetData())
   {
     //    m_WorkingImage->SurfaceStamp(dynamic_cast<mitk::Surface*>(m_InterpolatedSurfaceNode->GetData()), false);
     this->ShowInterpolationResult(false);
   }
 }
 
 void QmitkSurfaceBasedInterpolatorWidget::OnSurfaceInterpolationInfoChanged(const itk::EventObject & /*e*/)
 {
   if (m_Activated)
   {
     if (m_Watcher.isRunning())
       m_Watcher.waitForFinished();
 
     m_Future = QtConcurrent::run(this, &QmitkSurfaceBasedInterpolatorWidget::OnRunInterpolation);
     m_Watcher.setFuture(m_Future);
   }
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSurfaceBasedInterpolatorWidget.h b/Modules/SegmentationUI/Qmitk/QmitkSurfaceBasedInterpolatorWidget.h
index fb16e7f7b0..a4582310dc 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSurfaceBasedInterpolatorWidget.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkSurfaceBasedInterpolatorWidget.h
@@ -1,121 +1,119 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkSurfaceBasedInterpolatorWidgetWidget_h_Included
 #define QmitkSurfaceBasedInterpolatorWidgetWidget_h_Included
 
 #include "MitkSegmentationUIExports.h"
 #include "mitkDataNode.h"
 #include "mitkDataStorage.h"
 #include "mitkLabelSetImage.h"
 #include "mitkSurfaceBasedInterpolationController.h"
 
 #include <map>
 
 #include <QWidget>
 
 // For running 3D interpolation in background
 #include <QFuture>
 #include <QFutureWatcher>
 #include <QTimer>
 #include <QtConcurrentRun>
 
 #include "ui_QmitkSurfaceBasedInterpolatorWidgetGUIControls.h"
 
 namespace mitk
 {
   class ToolManager;
 }
 
 /**
   \brief GUI for surface-based interpolation.
 
   \ingroup ToolManagerEtAl
   \ingroup Widgets
 
   \sa QmitkInteractiveSegmentation
   \sa mitk::SurfaceBasedInterpolationController
 
   QmitkSurfaceBasedInterpolatorWidgetController is responsible to watch the GUI, to notice, which slice is currently
   visible. It triggers generation of interpolation suggestions and also triggers acception of suggestions.
-
-  This class uses the mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION context.
 */
 class MITKSEGMENTATIONUI_EXPORT QmitkSurfaceBasedInterpolatorWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   QmitkSurfaceBasedInterpolatorWidget(QWidget *parent = nullptr, const char *name = nullptr);
   ~QmitkSurfaceBasedInterpolatorWidget() override;
 
   void SetDataStorage(mitk::DataStorage &storage);
 
   void OnToolManagerWorkingDataModified();
 
   /**
      Just public because it is called by itk::Commands. You should not need to call this.
    */
   void OnSurfaceInterpolationInfoChanged(const itk::EventObject &);
 
   /**
    * @brief Set the visibility of the interpolation
    */
   void ShowInterpolationResult(bool);
 
   Ui::QmitkSurfaceBasedInterpolatorWidgetGUIControls m_Controls;
 
 public slots:
 
   /**
     \brief Reaction to "Start/Stop" button click
   */
   void OnToggleWidgetActivation(bool);
 
 protected slots:
 
   void OnAcceptInterpolationClicked();
 
   void OnSurfaceInterpolationFinished();
 
   void OnRunInterpolation();
 
   void OnShowMarkers(bool);
 
   void StartUpdateInterpolationTimer();
 
   void StopUpdateInterpolationTimer();
 
   void ChangeSurfaceColor();
 
 private:
   mitk::SurfaceBasedInterpolationController::Pointer m_SurfaceBasedInterpolatorController;
 
   mitk::ToolManager *m_ToolManager;
 
   bool m_Activated;
 
   unsigned int m_SurfaceInterpolationInfoChangedObserverTag;
 
   mitk::DataNode::Pointer m_InterpolatedSurfaceNode;
   mitk::DataNode::Pointer m_3DContourNode;
 
   mitk::DataStorage::Pointer m_DataStorage;
 
   mitk::LabelSetImage::Pointer m_WorkingImage;
 
   QFuture<void> m_Future;
   QFutureWatcher<void> m_Watcher;
   QTimer *m_Timer;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSurfaceStampWidget.cpp b/Modules/SegmentationUI/Qmitk/QmitkSurfaceStampWidget.cpp
index ad9a9a0f92..544ffbc76b 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSurfaceStampWidget.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSurfaceStampWidget.cpp
@@ -1,117 +1,117 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkSurfaceStampWidget.h"
 
 #include <mitkLabelSetImage.h>
 #include <mitkRenderingManager.h>
 #include <mitkSurface.h>
 #include <mitkToolManagerProvider.h>
 
 #include <QMessageBox>
 
 QmitkSurfaceStampWidget::QmitkSurfaceStampWidget(QWidget *parent, const char * /*name*/)
   : QWidget(parent), m_ToolManager(nullptr), m_DataStorage(nullptr)
 {
   m_Controls.setupUi(this);
   m_Controls.m_InformationWidget->hide();
 
-  m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
+  m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
   m_ToolManager->ActivateTool(-1);
 
   mitk::NodePredicateAnd::Pointer m_SurfacePredicate = mitk::NodePredicateAnd::New();
   m_SurfacePredicate->AddPredicate(mitk::NodePredicateDataType::New("Surface"));
   m_SurfacePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
 
   m_Controls.m_cbSurfaceNodeSelector->SetPredicate(m_SurfacePredicate);
 
   connect(m_Controls.m_pbStamp, SIGNAL(clicked()), this, SLOT(OnStamp()));
   connect(m_Controls.m_cbShowInformation, SIGNAL(toggled(bool)), this, SLOT(OnShowInformation(bool)));
   m_Controls.m_InformationWidget->hide();
 }
 
 QmitkSurfaceStampWidget::~QmitkSurfaceStampWidget()
 {
 }
 
 void QmitkSurfaceStampWidget::SetDataStorage(mitk::DataStorage *storage)
 {
   m_DataStorage = storage;
   m_Controls.m_cbSurfaceNodeSelector->SetDataStorage(m_DataStorage);
 }
 
 void QmitkSurfaceStampWidget::OnStamp()
 {
   mitk::DataNode *surfaceNode = m_Controls.m_cbSurfaceNodeSelector->GetSelectedNode();
 
   if (!surfaceNode)
   {
     QMessageBox::information(this, "Surface Stamp", "Please load and select a surface before starting some action.");
     return;
   }
 
-  m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
+  m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
   assert(m_ToolManager);
   m_ToolManager->ActivateTool(-1);
 
   mitk::Surface *surface = dynamic_cast<mitk::Surface *>(surfaceNode->GetData());
   if (!surface)
   {
     QMessageBox::information(this, "Surface Stamp", "Please load and select a surface before starting some action.");
     return;
   }
 
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
 
   if (!workingNode)
   {
     QMessageBox::information(
       this, "Surface Stamp", "Please load and select a segmentation before starting some action.");
     return;
   }
 
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
 
   if (!workingImage)
   {
     QMessageBox::information(
       this, "Surface Stamp", "Please load and select a segmentation before starting some action.");
     return;
   }
 
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
 
   try
   {
     //    workingImage->SurfaceStamp( surface, m_Controls.m_chkOverwrite->isChecked() );
   }
   catch (mitk::Exception &e)
   {
     QApplication::restoreOverrideCursor();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(
       this, "Surface Stamp", "Could not stamp the selected surface.\n See error log for details.\n");
     return;
   }
 
   QApplication::restoreOverrideCursor();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSurfaceStampWidget::OnShowInformation(bool on)
 {
   if (on)
     m_Controls.m_InformationWidget->show();
   else
     m_Controls.m_InformationWidget->hide();
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSurfaceStampWidget.h b/Modules/SegmentationUI/Qmitk/QmitkSurfaceStampWidget.h
index 852eced247..6320838ba2 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSurfaceStampWidget.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkSurfaceStampWidget.h
@@ -1,60 +1,58 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkSurfaceStampWidget_h_Included
 #define QmitkSurfaceStampWidget_h_Included
 
 #include "MitkSegmentationUIExports.h"
 
 #include <QWidget>
 
 #include "ui_QmitkSurfaceStampWidgetGUIControls.h"
 
 namespace mitk
 {
   class ToolManager;
 }
 
 /**
   \brief GUI for surface-based interpolation.
 
-  This class uses the mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION context.
-
   \ingroup ToolManagerEtAl
   \ingroup Widgets
 */
 
 class MITKSEGMENTATIONUI_EXPORT QmitkSurfaceStampWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   QmitkSurfaceStampWidget(QWidget *parent = nullptr, const char *name = nullptr);
   ~QmitkSurfaceStampWidget() override;
 
   void SetDataStorage(mitk::DataStorage *storage);
 
 protected slots:
 
   void OnShowInformation(bool);
 
   void OnStamp();
 
 private:
   mitk::ToolManager *m_ToolManager;
 
   mitk::DataStorage *m_DataStorage;
 
   Ui::QmitkSurfaceStampWidgetGUIControls m_Controls;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetFolderParser.h b/Modules/SegmentationUI/Qmitk/QmitknnUNetFolderParser.h
index 50e188bd8f..02eac9ea51 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetFolderParser.h
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetFolderParser.h
@@ -1,301 +1,301 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.s
 
 ============================================================================*/
 
 #ifndef QmitknnUNetFolderParser_h_Included
 #define QmitknnUNetFolderParser_h_Included
 
 #include "QmitknnUNetToolGUI.h"
 #include <QDirIterator>
 #include <QString>
 #include <vector>
 
 /**
  * @brief Struct to store each (Folder) Node of the hierarchy tree structure.
  * 
  */
 struct FolderNode
 {
   QString name;
   QString path; // parent
   std::vector<std::shared_ptr<FolderNode>> subFolders;
 };
 
 /**
  * @brief Class to store and retreive folder hierarchy information 
  * of RESULTS_FOLDER. Only Root node is explicitly stored in m_RootNode.
  * No. of sub levels in the hierachry is defined in the LEVEL constant.
  * 
  */
 class MITKSEGMENTATIONUI_EXPORT QmitknnUNetFolderParser
 {
 public:
 
   /**
    * @brief Construct a new QmitknnUNetFolderParser object
    * Initializes root folder node object pointer calls
    * @param parentFolder 
    */
   QmitknnUNetFolderParser(const QString parentFolder)
   {
     m_RootNode = std::make_shared<FolderNode>();
     m_RootNode->path = parentFolder;
     m_RootNode->name = QString("nnUNet");
     m_RootNode->subFolders.clear();
     InitDirs(m_RootNode, 0);
   }
 
   /**
    * @brief Destroy the QmitknnUNetFolderParser object
    * 
    */
   ~QmitknnUNetFolderParser() = default; /*{ DeleteDirs(m_RootNode, LEVEL); }*/
 
   /**
    * @brief Returns the "Results Folder" string which is parent path of the root node.
    * 
    * @return QString 
    */
   QString getResultsFolder() { return m_RootNode->path; }
 
   /**
    * @brief Returns the Model Names from root node. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getModelNames()
   {
     auto models = GetSubFolderNamesFromNode<T>(m_RootNode);
     return models;
   }
   
   /**
    * @brief Returns the task names for a given model. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param modelName
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getTasksForModel(const QString &modelName)
   {
     std::shared_ptr<FolderNode> modelNode = GetSubNodeMatchingNameCrietria(modelName, m_RootNode);
     auto tasks = GetSubFolderNamesFromNode<T>(modelNode);
     return tasks;
   }
 
   /**
    * @brief Returns the models names for a given task. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param taskName
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getModelsForTask(const QString &taskName)
   {
     T modelsForTask;
     auto models = GetSubFolderNamesFromNode<T>(m_RootNode);
     foreach (QString model, models)
     {
       QStringList taskList = getTasksForModel<QStringList>(model);
       if (taskList.contains(taskName, Qt::CaseInsensitive))
       {
         modelsForTask << model;
       }
     }
     return modelsForTask;
   }
 
   /**
    * @brief Returns all the task names present in the root node with possible duplicates.
    * Template function, type can be any of stl or Qt containers which supports push_back call.
    * 
-   * @tparam T 
+   * @param T 
    * @param taskName
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getAllTasks()
   {
     T allTasks;
     auto models = GetSubFolderNamesFromNode<T>(m_RootNode);
     foreach (QString model, models)
     {
       allTasks << getTasksForModel<QStringList>(model);
     }
     return allTasks;
   }
 
   /**
    * @brief Returns the trainer / planner names for a given task & model. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param taskName
    * @param modelName
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getTrainerPlannersForTask(const QString &taskName, const QString &modelName)
   {
     std::shared_ptr<FolderNode> modelNode = GetSubNodeMatchingNameCrietria(modelName, m_RootNode);
     std::shared_ptr<FolderNode> taskNode = GetSubNodeMatchingNameCrietria(taskName, modelNode);
     auto tps = GetSubFolderNamesFromNode<T>(taskNode);
     return tps;
   }
 
   /**
    * @brief Returns the Folds names for a given trainer,planner,task & model name. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param trainer
    * @param planner
    * @param taskName
    * @param modelName
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getFoldsForTrainerPlanner(const QString &trainer,
                               const QString &planner,
                               const QString &taskName,
                               const QString &modelName)
   {
     std::shared_ptr<FolderNode> modelNode = GetSubNodeMatchingNameCrietria(modelName, m_RootNode);
     std::shared_ptr<FolderNode> taskNode = GetSubNodeMatchingNameCrietria(taskName, modelNode);
     QString trainerPlanner = trainer + QString("__") + planner;
     std::shared_ptr<FolderNode> tpNode = GetSubNodeMatchingNameCrietria(trainerPlanner, taskNode);
     auto folds = GetSubFolderNamesFromNode<T>(tpNode);
     return folds;
   }
 
 private:
   const int m_LEVEL = 4;
   std::shared_ptr<FolderNode> m_RootNode;
 
   /**
    * @brief Iterates through the root node and returns the sub FolderNode object Matching Name Crietria 
    * 
    * @param queryName 
    * @param parentNode 
    * @return std::shared_ptr<FolderNode> 
    */
   std::shared_ptr<FolderNode> GetSubNodeMatchingNameCrietria(const QString &queryName,
                                                              std::shared_ptr<FolderNode> parentNode)
   {
     std::shared_ptr<FolderNode> retNode;
     std::vector<std::shared_ptr<FolderNode>> subNodes = parentNode->subFolders;
     for (std::shared_ptr<FolderNode> node : subNodes)
     {
       if (node->name == queryName)
       {
         retNode = node;
         break;
       }
     }
     return retNode;
   }
 
   /**
    * @brief Returns the sub folder names for a folder node object. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param std::shared_ptr<FolderNode>
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T GetSubFolderNamesFromNode(const std::shared_ptr<FolderNode> parent)
   {
     T folders;
     std::vector<std::shared_ptr<FolderNode>> subNodes = parent->subFolders;
     for (std::shared_ptr<FolderNode> folder : subNodes)
     {
       folders.push_back(folder->name);
     }
     return folders;
   }
 
   /**
    * @brief Iterates through the sub folder hierarchy upto a level provided
    * and create a tree structure.
    * 
    * @param parent 
    * @param level 
    */
   void InitDirs(std::shared_ptr<FolderNode> parent, int level)
   {
     QString searchFolder = parent->path + QDir::separator() + parent->name;
     auto subFolders = FetchFoldersFromDir<QStringList>(searchFolder);
     level++;
     foreach (QString folder, subFolders)
     {
       std::shared_ptr<FolderNode> fp = std::make_shared<FolderNode>();
       fp->path = searchFolder;
       fp->name = folder;
       if (level < this->m_LEVEL)
       {
         InitDirs(fp, level);
       }
       parent->subFolders.push_back(fp);
     }
   }
 
   /**
    * @brief Iterates through the sub folder hierarchy upto a level provided
    * and clears the sub folder std::vector from each node.
    * 
    * @param parent 
    * @param level 
    */
   void DeleteDirs(std::shared_ptr<FolderNode> parent, int level)
   {
     level++;
     for (std::shared_ptr<FolderNode> subFolder : parent->subFolders)
     {
       if (level < m_LEVEL)
       {
         DeleteDirs(subFolder, level);
       }
       parent->subFolders.clear();
     }
   }
 
   /**
    * @brief Template function to fetch all folders inside a given path.
    * The type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param path 
    * @return T 
    */
   template <typename T>
   T FetchFoldersFromDir(const QString &path)
   {
     T folders;
     for (QDirIterator it(path, QDir::AllDirs, QDirIterator::NoIteratorFlags); it.hasNext();)
     {
       it.next();
       if (!it.fileName().startsWith('.'))
       {
         folders.push_back(it.fileName());
       }
     }
     return folders;
   }
 };
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
index 29114ac8f8..354beea484 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
@@ -1,588 +1,1176 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitknnUNetToolGUI.h"
 
 #include "mitkProcessExecutor.h"
 #include "mitknnUnetTool.h"
 #include <QApplication>
 #include <QDir>
+#include <QDirIterator>
 #include <QIcon>
-#include <QJsonDocument>
-#include <QJsonObject>
 #include <QmitkStyleManager.h>
+#include <QmitknnUNetEnsembleLayout.h>
 #include <QtGlobal>
+#include <algorithm>
+#include <ctkCollapsibleGroupBox.h>
 #include <itksys/SystemTools.hxx>
-#include <set>
+#include <nlohmann/json.hpp>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitknnUNetToolGUI, "")
 
-QmitknnUNetToolGUI::QmitknnUNetToolGUI() : QmitkAutoMLSegmentationToolGUIBase()
+QmitknnUNetToolGUI::QmitknnUNetToolGUI() : QmitkMultiLabelSegWithPreviewToolGUIBase()
 {
   // Nvidia-smi command returning zero doesn't always imply lack of GPUs.
   // Pytorch uses its own libraries to communicate to the GPUs. Hence, only a warning can be given.
   if (m_GpuLoader.GetGPUCount() == 0)
   {
     std::string warning = "WARNING: No GPUs were detected on your machine. The nnUNet tool might not work.";
-    ShowErrorMessage(warning);
+    this->ShowErrorMessage(warning);
   }
 
   // define predicates for multi modal data selection combobox
   auto imageType = mitk::TNodePredicateDataType<mitk::Image>::New();
   auto labelSetImageType = mitk::NodePredicateNot::New(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   m_MultiModalPredicate = mitk::NodePredicateAnd::New(imageType, labelSetImageType).GetPointer();
+
+  m_nnUNetThread = new QThread(this);
+  m_Worker = new nnUNetDownloadWorker;
+  m_Worker->moveToThread(m_nnUNetThread);
+}
+
+QmitknnUNetToolGUI::~QmitknnUNetToolGUI()
+{
+  m_nnUNetThread->quit();
+  m_nnUNetThread->wait();
 }
 
-void QmitknnUNetToolGUI::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool *newTool)
+void QmitknnUNetToolGUI::ConnectNewTool(mitk::SegWithPreviewTool *newTool)
 {
   Superclass::ConnectNewTool(newTool);
   newTool->IsTimePointChangeAwareOff();
 }
 
 void QmitknnUNetToolGUI::InitializeUI(QBoxLayout *mainLayout)
 {
   m_Controls.setupUi(this);
 #ifndef _WIN32
   m_Controls.pythonEnvComboBox->addItem("/usr/bin");
 #endif
   m_Controls.pythonEnvComboBox->addItem("Select");
   AutoParsePythonPaths();
   SetGPUInfo();
   connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnPreviewRequested()));
   connect(m_Controls.modeldirectoryBox,
           SIGNAL(directoryChanged(const QString &)),
           this,
           SLOT(OnDirectoryChanged(const QString &)));
   connect(
     m_Controls.modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
   connect(m_Controls.taskBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTaskChanged(const QString &)));
   connect(
     m_Controls.plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
   connect(m_Controls.multiModalBox, SIGNAL(stateChanged(int)), this, SLOT(OnCheckBoxChanged(int)));
   connect(m_Controls.multiModalSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnModalitiesNumberChanged(int)));
   connect(m_Controls.pythonEnvComboBox,
 #if QT_VERSION >= 0x050F00 // 5.15
           SIGNAL(textActivated(const QString &)),
 #elif QT_VERSION >= 0x050C00 // 5.12
           SIGNAL(currentTextChanged(const QString &)),
 #endif
           this,
           SLOT(OnPythonPathChanged(const QString &)));
   connect(m_Controls.refreshdirectoryBox, SIGNAL(clicked()), this, SLOT(OnRefreshPresssed()));
   connect(m_Controls.clearCacheButton, SIGNAL(clicked()), this, SLOT(OnClearCachePressed()));
+  connect(m_Controls.startDownloadButton, SIGNAL(clicked()), this, SLOT(OnDownloadModel()));
+  connect(m_Controls.stopDownloadButton, SIGNAL(clicked()), this, SLOT(OnStopDownload()));
+
+  // Qthreads
+  qRegisterMetaType<mitk::ProcessExecutor::Pointer>();
+  qRegisterMetaType<mitk::ProcessExecutor::ArgumentListType>();
+  connect(this, &QmitknnUNetToolGUI::Operate, m_Worker, &nnUNetDownloadWorker::DoWork);
+  connect(m_Worker, &nnUNetDownloadWorker::Exit, this, &QmitknnUNetToolGUI::OnDownloadWorkerExit);
+  connect(m_nnUNetThread, &QThread::finished, m_Worker, &QObject::deleteLater);
 
   m_Controls.multiModalSpinBox->setVisible(false);
   m_Controls.multiModalSpinBox->setEnabled(false);
   m_Controls.multiModalSpinLabel->setVisible(false);
+  m_Controls.stopDownloadButton->setVisible(false);
   m_Controls.previewButton->setEnabled(false);
 
   QIcon refreshIcon =
     QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/view-refresh.svg"));
   m_Controls.refreshdirectoryBox->setIcon(refreshIcon);
   QIcon dirIcon =
     QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-open.svg"));
   m_Controls.modeldirectoryBox->setIcon(dirIcon);
   m_Controls.refreshdirectoryBox->setEnabled(true);
+  QIcon stopIcon =
+    QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/status/dialog-error.svg"));
+  m_Controls.stopDownloadButton->setIcon(stopIcon);
 
   m_Controls.statusLabel->setTextFormat(Qt::RichText);
   if (m_GpuLoader.GetGPUCount() != 0)
   {
     WriteStatusMessage(QString("<b>STATUS: </b><i>Welcome to nnUNet. " + QString::number(m_GpuLoader.GetGPUCount()) +
                                " GPUs were detected.</i>"));
   }
   else
   {
     WriteErrorMessage(QString("<b>STATUS: </b><i>Welcome to nnUNet. " + QString::number(m_GpuLoader.GetGPUCount()) +
                               " GPUs were detected.</i>"));
   }
   mainLayout->addLayout(m_Controls.verticalLayout);
   Superclass::InitializeUI(mainLayout);
   m_UI_ROWS = m_Controls.advancedSettingsLayout->rowCount(); // Must do. Row count is correct only here.
-  DisableEverything();
+  this->DisableEverything();
   QString lastSelectedPyEnv = m_Settings.value("nnUNet/LastPythonPath").toString();
   m_Controls.pythonEnvComboBox->setCurrentText(lastSelectedPyEnv);
 }
 
-void QmitknnUNetToolGUI::OnPreviewRequested()
+void QmitknnUNetToolGUI::EnableWidgets(bool enabled)
 {
-  mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
-  if (nullptr != tool)
+  Superclass::EnableWidgets(enabled);
+}
+
+void QmitknnUNetToolGUI::ClearAllModalities()
+{
+  m_Controls.multiModalSpinBox->setMinimum(0);
+  m_Controls.multiModalBox->setChecked(false);
+  this->ClearAllModalLabels();
+}
+
+void QmitknnUNetToolGUI::ClearAllModalLabels()
+{
+  for (auto modalLabel : m_ModalLabels)
   {
-    QString pythonPathTextItem = "";
-    try
-    {
-      size_t hashKey(0);
-      m_Controls.previewButton->setEnabled(false); // To prevent misclicked back2back prediction.
-      qApp->processEvents();
-      tool->PredictOn(); // purposefully placed to make tool->GetMTime different than before.
-      QString modelName = m_Controls.modelBox->currentText();
-      if (modelName.startsWith("ensemble", Qt::CaseInsensitive))
-      {
-        ProcessEnsembleModelsParams(tool);
-      }
-      else
-      {
-        ProcessModelParams(tool);
-      }
-      pythonPathTextItem = m_Controls.pythonEnvComboBox->currentText();
-      QString pythonPath = m_PythonPath;
-      if (!IsNNUNetInstalled(pythonPath))
-      {
-        throw std::runtime_error("nnUNet is not detected in the selected python environment. Please select a valid "
-                                 "python environment or install nnUNet.");
-      }
-      tool->SetPythonPath(pythonPath.toStdString());
-      tool->SetModelDirectory(m_ParentFolder->getResultsFolder().toStdString());
-      // checkboxes
-      tool->SetMirror(m_Controls.mirrorBox->isChecked());
-      tool->SetMixedPrecision(m_Controls.mixedPrecisionBox->isChecked());
-      tool->SetNoPip(false);
-      bool doCache = m_Controls.enableCachingCheckBox->isChecked();
-      // Spinboxes
-      tool->SetGpuId(FetchSelectedGPUFromUI());
-      // Multi-Modal
-      tool->MultiModalOff();
-      if (m_Controls.multiModalBox->isChecked())
-      {
-        if (m_Controls.multiModalSpinBox->value() > 0)
-        {
-          tool->m_OtherModalPaths.clear();
-          tool->m_OtherModalPaths = FetchMultiModalImagesFromUI();
-          tool->MultiModalOn();
-        }
-        else
-        {
-          throw std::runtime_error("Please select more than one modalities for a multi-modal task. If you "
-                                   "would like to use only one modality then uncheck the Multi-Modal option.");
-        }
-      }
-      if (doCache)
-      {
-        hashKey = nnUNetCache::GetUniqueHash(tool->m_ParamQ);
-        if (m_Cache.contains(hashKey))
-        {
-          tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
-        }
-      }
-      if (tool->GetPredict())
-      {
-        tool->m_InputBuffer = nullptr;
-        WriteStatusMessage(QString("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>"));
-        tool->UpdatePreview();
-        if (nullptr == tool->GetOutputBuffer())
-        {
-          SegmentationProcessFailed();
-        }
-        else
-        {
-          SegmentationResultHandler(tool);
-          if (doCache)
-          {
-            AddToCache(hashKey, tool->GetMLPreview());
-          }
-        }
-        tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
-      }
-      else
-      {
-        MITK_INFO << "won't do segmentation. Key found: " << QString::number(hashKey).toStdString();
-        if (m_Cache.contains(hashKey))
-        {
-          nnUNetCache *cacheObject = m_Cache[hashKey];
-          MITK_INFO << "fetched pointer " << cacheObject->m_SegCache.GetPointer();
-          tool->SetOutputBuffer(const_cast<mitk::LabelSetImage *>(cacheObject->m_SegCache.GetPointer()));
-          SegmentationResultHandler(tool, true);
-        }
-      }
-      m_Controls.previewButton->setEnabled(true);
-    }
-    catch (const std::exception &e)
-    {
-      std::stringstream errorMsg;
-      errorMsg << "<b>STATUS: </b>Error while processing parameters for nnUNet segmentation. Reason: " << e.what();
-      ShowErrorMessage(errorMsg.str());
-      WriteErrorMessage(QString::fromStdString(errorMsg.str()));
-      m_Controls.previewButton->setEnabled(true);
-      tool->PredictOff();
-      return;
-    }
-    catch (...)
-    {
-      std::string errorMsg = "Unkown error occured while generation nnUNet segmentation.";
-      ShowErrorMessage(errorMsg);
-      m_Controls.previewButton->setEnabled(true);
-      tool->PredictOff();
-      return;
-    }
-    if (!pythonPathTextItem.isEmpty())
-    { // only cache if the prediction ended without errors.
-      m_Settings.setValue("nnUNet/LastPythonPath", pythonPathTextItem);
-    }
+    delete modalLabel; // delete the layout item
+    m_ModalLabels.pop_back();
   }
+  m_Controls.advancedSettingsLayout->update();
+}
+
+void QmitknnUNetToolGUI::DisableEverything()
+{
+  m_Controls.modeldirectoryBox->setEnabled(false);
+  m_Controls.refreshdirectoryBox->setEnabled(false);
+  m_Controls.previewButton->setEnabled(false);
+  m_Controls.multiModalSpinBox->setVisible(false);
+  m_Controls.multiModalBox->setEnabled(false);
+  this->ClearAllComboBoxes();
+  this->ClearAllModalities();
+}
+
+void QmitknnUNetToolGUI::ClearAllComboBoxes()
+{
+  m_Controls.modelBox->clear();
+  m_Controls.taskBox->clear();
+  m_Controls.foldBox->clear();
+  m_Controls.trainerBox->clear();
+  m_Controls.plannerBox->clear();
+  for (auto &layout : m_EnsembleParams)
+  {
+    layout->modelBox->clear();
+    layout->trainerBox->clear();
+    layout->plannerBox->clear();
+    layout->foldBox->clear();
+  }
+  m_Controls.availableBox->clear();
 }
 
 std::vector<mitk::Image::ConstPointer> QmitknnUNetToolGUI::FetchMultiModalImagesFromUI()
 {
   std::vector<mitk::Image::ConstPointer> modals;
   if (m_Controls.multiModalBox->isChecked() && !m_Modalities.empty())
   {
     std::set<std::string> nodeNames; // set container for keeping names of all nodes to check if they are added twice.
     for (QmitkDataStorageComboBox *modality : m_Modalities)
     {
       if (nodeNames.find(modality->GetSelectedNode()->GetName()) == nodeNames.end())
       {
         modals.push_back(dynamic_cast<const mitk::Image *>(modality->GetSelectedNode()->GetData()));
         nodeNames.insert(modality->GetSelectedNode()->GetName());
       }
       else
       {
         throw std::runtime_error("Same modality is selected more than once. Please change your selection.");
         break;
       }
     }
   }
   return modals;
 }
 
 bool QmitknnUNetToolGUI::IsNNUNetInstalled(const QString &pythonPath)
 {
   QString fullPath = pythonPath;
 #ifdef _WIN32
   if (!(fullPath.endsWith("Scripts", Qt::CaseInsensitive) || fullPath.endsWith("Scripts/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("Scripts");
   }
 #else
   if (!(fullPath.endsWith("bin", Qt::CaseInsensitive) || fullPath.endsWith("bin/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("bin");
   }
 #endif
   fullPath = fullPath.mid(fullPath.indexOf(" ") + 1);
   bool isExists = QFile::exists(fullPath + QDir::separator() + QString("nnUNet_predict")) &&
                   QFile::exists(fullPath + QDir::separator() + QString("python3"));
   return isExists;
 }
 
 void QmitknnUNetToolGUI::ShowErrorMessage(const std::string &message, QMessageBox::Icon icon)
 {
   this->setCursor(Qt::ArrowCursor);
   QMessageBox *messageBox = new QMessageBox(icon, nullptr, message.c_str());
   messageBox->exec();
   delete messageBox;
   MITK_WARN << message;
 }
 
 void QmitknnUNetToolGUI::WriteStatusMessage(const QString &message)
 {
   m_Controls.statusLabel->setText(message);
   m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: white");
 }
 
 void QmitknnUNetToolGUI::WriteErrorMessage(const QString &message)
 {
   m_Controls.statusLabel->setText(message);
   m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: red");
 }
 
 void QmitknnUNetToolGUI::ProcessEnsembleModelsParams(mitk::nnUNetTool::Pointer tool)
 {
   if (m_EnsembleParams[0]->modelBox->currentText() == m_EnsembleParams[1]->modelBox->currentText())
   {
     throw std::runtime_error("Both models you have selected for ensembling are the same.");
   }
   QString taskName = m_Controls.taskBox->currentText();
   bool isPPJson = m_Controls.postProcessingCheckBox->isChecked();
   std::vector<mitk::ModelParams> requestQ;
   QString ppDirFolderNamePart1 = "ensemble_";
   QStringList ppDirFolderNameParts;
   for (auto &layout : m_EnsembleParams)
   {
     QStringList ppDirFolderName;
     QString modelName = layout->modelBox->currentText();
     ppDirFolderName << modelName;
     ppDirFolderName << "__";
     QString trainer = layout->trainerBox->currentText();
     ppDirFolderName << trainer;
     ppDirFolderName << "__";
     QString planId = layout->plannerBox->currentText();
     ppDirFolderName << planId;
 
-    if (!IsModelExists(modelName, taskName, QString(trainer + "__" + planId)))
+    if (!this->IsModelExists(modelName, taskName, QString(trainer + "__" + planId)))
     {
       std::string errorMsg = "The configuration " + modelName.toStdString() +
                              " you have selected doesn't exist. Check your Results Folder again.";
       throw std::runtime_error(errorMsg);
     }
     std::vector<std::string> testfold = FetchSelectedFoldsFromUI(layout->foldBox);
     mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, testfold);
     requestQ.push_back(modelObject);
     ppDirFolderNameParts << ppDirFolderName.join(QString(""));
   }
   tool->EnsembleOn();
   if (isPPJson)
   {
     QString ppJsonFilePossibility1 = QDir::cleanPath(
       m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + "ensembles" +
       QDir::separator() + taskName + QDir::separator() + ppDirFolderNamePart1 + ppDirFolderNameParts.first() + "--" +
       ppDirFolderNameParts.last() + QDir::separator() + "postprocessing.json");
     QString ppJsonFilePossibility2 = QDir::cleanPath(
       m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + "ensembles" +
       QDir::separator() + taskName + QDir::separator() + ppDirFolderNamePart1 + ppDirFolderNameParts.last() + "--" +
       ppDirFolderNameParts.first() + QDir::separator() + "postprocessing.json");
 
     if (QFile(ppJsonFilePossibility1).exists())
     {
       tool->SetPostProcessingJsonDirectory(ppJsonFilePossibility1.toStdString());
       const QString statusMsg = "<i>Post Processing JSON file found: </i>" + ppJsonFilePossibility1;
-      WriteStatusMessage(statusMsg);
+      this->WriteStatusMessage(statusMsg);
     }
     else if (QFile(ppJsonFilePossibility2).exists())
     {
       tool->SetPostProcessingJsonDirectory(ppJsonFilePossibility2.toStdString());
       const QString statusMsg = "<i>Post Processing JSON file found:</i>" + ppJsonFilePossibility2;
-      WriteStatusMessage(statusMsg);
+      this->WriteStatusMessage(statusMsg);
     }
     else
     {
       std::string errorMsg =
         "No post processing file was found for the selected ensemble combination. Continuing anyway...";
-      ShowErrorMessage(errorMsg);
+      this->ShowErrorMessage(errorMsg);
     }
   }
   tool->m_ParamQ.clear();
   tool->m_ParamQ = requestQ;
 }
 
 void QmitknnUNetToolGUI::ProcessModelParams(mitk::nnUNetTool::Pointer tool)
 {
   tool->EnsembleOff();
   std::vector<mitk::ModelParams> requestQ;
   QString modelName = m_Controls.modelBox->currentText();
   QString taskName = m_Controls.taskBox->currentText();
   QString trainer = m_Controls.trainerBox->currentText();
   QString planId = m_Controls.plannerBox->currentText();
-  std::vector<std::string> fetchedFolds = FetchSelectedFoldsFromUI(m_Controls.foldBox);
+  std::vector<std::string> fetchedFolds = this->FetchSelectedFoldsFromUI(m_Controls.foldBox);
   mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, fetchedFolds);
   requestQ.push_back(modelObject);
   tool->m_ParamQ.clear();
   tool->m_ParamQ = requestQ;
 }
 
 bool QmitknnUNetToolGUI::IsModelExists(const QString &modelName, const QString &taskName, const QString &trainerPlanner)
 {
   QString modelSearchPath =
     QDir::cleanPath(m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + modelName +
                     QDir::separator() + taskName + QDir::separator() + trainerPlanner);
   if (QDir(modelSearchPath).exists())
   {
     return true;
   }
   return false;
 }
 
 void QmitknnUNetToolGUI::CheckAllInCheckableComboBox(ctkCheckableComboBox *foldBox)
 {
   // Recalling all added items to check-mark it.
   const QAbstractItemModel *qaim = foldBox->checkableModel();
   auto rows = qaim->rowCount();
   for (std::remove_const_t<decltype(rows)> i = 0; i < rows; ++i)
   {
     const QModelIndex mi = qaim->index(i, 0);
     foldBox->setCheckState(mi, Qt::Checked);
   }
 }
 
 std::pair<QStringList, QStringList> QmitknnUNetToolGUI::ExtractTrainerPlannerFromString(QStringList trainerPlanners)
 {
   QString splitterString = "__";
   QStringList trainers, planners;
   for (const auto &trainerPlanner : trainerPlanners)
   {
     trainers << trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts).first();
     planners << trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts).last();
   }
   trainers.removeDuplicates();
   planners.removeDuplicates();
   return std::make_pair(trainers, planners);
 }
 
 std::vector<std::string> QmitknnUNetToolGUI::FetchSelectedFoldsFromUI(ctkCheckableComboBox *foldBox)
 {
   std::vector<std::string> folds;
   if (foldBox->noneChecked())
   {
-    CheckAllInCheckableComboBox(foldBox);
+    this->CheckAllInCheckableComboBox(foldBox);
   }
   QModelIndexList foldList = foldBox->checkedIndexes();
   for (const auto &index : foldList)
   {
     QString foldQString = foldBox->itemText(index.row()).split("_", QString::SplitBehavior::SkipEmptyParts).last();
     folds.push_back(foldQString.toStdString());
   }
   return folds;
 }
 
-void QmitknnUNetToolGUI::OnClearCachePressed()
-{
-  m_Cache.clear();
-  UpdateCacheCountOnUI();
-}
-
 void QmitknnUNetToolGUI::UpdateCacheCountOnUI()
 {
   QString cacheText = m_CACHE_COUNT_BASE_LABEL + QString::number(m_Cache.size());
   m_Controls.cacheCountLabel->setText(cacheText);
 }
 
 void QmitknnUNetToolGUI::AddToCache(size_t &hashKey, mitk::LabelSetImage::ConstPointer mlPreview)
 {
   nnUNetCache *newCacheObj = new nnUNetCache;
   newCacheObj->m_SegCache = mlPreview;
   m_Cache.insert(hashKey, newCacheObj);
   MITK_INFO << "New hash: " << hashKey << " " << newCacheObj->m_SegCache.GetPointer();
-  UpdateCacheCountOnUI();
+  this->UpdateCacheCountOnUI();
 }
 
 void QmitknnUNetToolGUI::SetGPUInfo()
 {
   std::vector<QmitkGPUSpec> specs = m_GpuLoader.GetAllGPUSpecs();
   for (const QmitkGPUSpec &gpuSpec : specs)
   {
     m_Controls.gpuComboBox->addItem(QString::number(gpuSpec.id) + ": " + gpuSpec.name + " (" + gpuSpec.memory + ")");
   }
   if (specs.empty())
   {
     m_Controls.gpuComboBox->setEditable(true);
     m_Controls.gpuComboBox->addItem(QString::number(0));
     m_Controls.gpuComboBox->setValidator(new QIntValidator(0, 999, this));
   }
 }
 
 unsigned int QmitknnUNetToolGUI::FetchSelectedGPUFromUI()
 {
   QString gpuInfo = m_Controls.gpuComboBox->currentText();
   if (m_GpuLoader.GetGPUCount() == 0)
   {
     return static_cast<unsigned int>(gpuInfo.toInt());
   }
   else
   {
     QString gpuId = gpuInfo.split(":", QString::SplitBehavior::SkipEmptyParts).first();
     return static_cast<unsigned int>(gpuId.toInt());
   }
 }
 
 QString QmitknnUNetToolGUI::FetchResultsFolderFromEnv()
 {
   const char *pathVal = itksys::SystemTools::GetEnv("RESULTS_FOLDER");
   QString retVal;
   if (pathVal)
   {
     retVal = QString::fromUtf8(pathVal);
   }
   else
   {
     retVal = m_Settings.value("nnUNet/LastRESULTS_FOLDERPath").toString();
   }
   return retVal;
 }
 
-QString QmitknnUNetToolGUI::DumpJSONfromPickle(const QString &parentPath)
+void QmitknnUNetToolGUI::DumpAllJSONs(const QString &path)
 {
-  const QString picklePath = parentPath + QDir::separator() + QString("plans.pkl");
-  const QString jsonPath = parentPath + QDir::separator() + QString("mitk_export.json");
-  if (!QFile::exists(jsonPath))
+  this->DumpJSONfromPickle(path);
+  this->ExportAvailableModelsAsJSON(m_ParentFolder->getResultsFolder());
+}
+
+void QmitknnUNetToolGUI::DumpJSONfromPickle(const QString &picklePath)
+{
+  const QString pickleFile = picklePath + QDir::separator() + m_PICKLE_FILENAME;
+  const QString jsonFile = picklePath + QDir::separator() + m_MITK_EXPORT_JSON_FILENAME;
+  if (!QFile::exists(jsonFile))
   {
     mitk::ProcessExecutor::Pointer spExec = mitk::ProcessExecutor::New();
-    itk::CStyleCommand::Pointer spCommand = itk::CStyleCommand::New();
     mitk::ProcessExecutor::ArgumentListType args;
     args.push_back("-c");
     std::string pythonCode; // python syntax to parse plans.pkl file and export as Json file.
     pythonCode.append("import pickle;");
     pythonCode.append("import json;");
     pythonCode.append("loaded_pickle = pickle.load(open('");
-    pythonCode.append(picklePath.toStdString());
+    pythonCode.append(pickleFile.toStdString());
     pythonCode.append("','rb'));");
     pythonCode.append("modal_dict = {key: loaded_pickle[key] for key in loaded_pickle.keys() if key in "
                       "['modalities','num_modalities']};");
     pythonCode.append("json.dump(modal_dict, open('");
-    pythonCode.append(jsonPath.toStdString());
+    pythonCode.append(jsonFile.toStdString());
     pythonCode.append("', 'w'))");
 
     args.push_back(pythonCode);
     try
     {
       spExec->Execute(m_PythonPath.toStdString(), "python3", args);
     }
     catch (const mitk::Exception &e)
     {
-      MITK_ERROR << "Pickle parsing FAILED!" << e.GetDescription(); // SHOW ERROR
-      WriteStatusMessage(
+      MITK_ERROR << "Pickle parsing FAILED!" << e.GetDescription();
+      this->WriteStatusMessage(
         "Parsing failed in backend. Multiple Modalities will now have to be manually entered by the user.");
-      return QString("");
     }
   }
-  return jsonPath;
+}
+
+void QmitknnUNetToolGUI::ExportAvailableModelsAsJSON(const QString &resultsFolder)
+{
+  const QString jsonPath = resultsFolder + QDir::separator() + m_AVAILABLE_MODELS_JSON_FILENAME;
+  if (!QFile::exists(jsonPath))
+  {
+    auto spExec = mitk::ProcessExecutor::New();
+    mitk::ProcessExecutor::ArgumentListType args;
+    args.push_back("--export");
+    args.push_back(resultsFolder.toStdString());
+    try
+    {
+      spExec->Execute(m_PythonPath.toStdString(), "nnUNet_print_available_pretrained_models", args);
+    }
+    catch (const mitk::Exception &e)
+    {
+      MITK_ERROR << "Exporting information FAILED." << e.GetDescription();
+      this->WriteStatusMessage("Exporting information FAILED.");
+    }
+  }
 }
 
 void QmitknnUNetToolGUI::DisplayMultiModalInfoFromJSON(const QString &jsonPath)
 {
-  if (QFile::exists(jsonPath))
+  std::ifstream file(jsonPath.toStdString());
+  if (file.is_open())
   {
-    QFile file(jsonPath);
-    if (file.open(QIODevice::ReadOnly | QIODevice::Text))
+    auto jsonObj = nlohmann::json::parse(file, nullptr, false);
+
+    if (jsonObj.is_discarded() || !jsonObj.is_object())
     {
-      QByteArray bytes = file.readAll();
-      file.close();
+      MITK_ERROR << "Could not parse \"" << jsonPath.toStdString() << "\" as JSON object!";
+      return;
+    }
+    auto num_mods = jsonObj["num_modalities"].get<int>();
+    this->ClearAllModalLabels();
+    if (num_mods > 1)
+    {
+      m_Controls.multiModalBox->setChecked(true);
+      m_Controls.multiModalBox->setEnabled(false);
+      m_Controls.multiModalSpinBox->setValue(num_mods - 1);
+      m_Controls.advancedSettingsLayout->update();
+      auto obj = jsonObj["modalities"];
+      int count = 0;
+      for (const auto &value : obj)
+      {
+        QLabel *label = new QLabel(QString::fromStdString("<i>" + value.get<std::string>() + "</i>"), this);
+        m_ModalLabels.push_back(label);
+        m_Controls.advancedSettingsLayout->addWidget(label, m_UI_ROWS + 1 + count, 0);
+        count++;
+      }
+      m_Controls.multiModalSpinBox->setMinimum(num_mods - 1);
+      m_Controls.advancedSettingsLayout->update();
+    }
+    else
+    {
+      m_Controls.multiModalSpinBox->setMinimum(0);
+      m_Controls.multiModalBox->setChecked(false);
+    }
+  }
+}
 
-      QJsonParseError jsonError;
-      QJsonDocument document = QJsonDocument::fromJson(bytes, &jsonError);
-      if (jsonError.error != QJsonParseError::NoError)
+void QmitknnUNetToolGUI::FillAvailableModelsInfoFromJSON(const QString &jsonPath)
+{
+  std::ifstream file(jsonPath.toStdString());
+  if (file.is_open() && m_Controls.availableBox->count() < 1)
+  {
+    auto jsonObj = nlohmann::json::parse(file, nullptr, false);
+    if (jsonObj.is_discarded() || !jsonObj.is_object())
+    {
+      MITK_ERROR << "Could not parse \"" << jsonPath.toStdString() << "\" as JSON object!";
+      return;
+    }
+    for (const auto &obj : jsonObj.items())
+    {
+      m_Controls.availableBox->addItem(QString::fromStdString(obj.key()));
+    }
+  }
+}
+
+mitk::ModelParams QmitknnUNetToolGUI::MapToRequest(const QString &modelName,
+                                                   const QString &taskName,
+                                                   const QString &trainer,
+                                                   const QString &planId,
+                                                   const std::vector<std::string> &folds)
+{
+  mitk::ModelParams requestObject;
+  requestObject.model = modelName.toStdString();
+  requestObject.trainer = trainer.toStdString();
+  requestObject.planId = planId.toStdString();
+  requestObject.task = taskName.toStdString();
+  requestObject.folds = folds;
+  mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
+  requestObject.inputName = tool->GetRefNode()->GetName();
+  requestObject.timeStamp =
+    std::to_string(mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint());
+  return requestObject;
+}
+
+/* ---------------------SLOTS---------------------------------------*/
+
+void QmitknnUNetToolGUI::OnPreviewRequested()
+{
+  mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
+  if (nullptr != tool)
+  {
+    QString pythonPathTextItem = "";
+    try
+    {
+      size_t hashKey(0);
+      m_Controls.previewButton->setEnabled(false); // To prevent misclicked back2back prediction.
+      qApp->processEvents();
+      tool->PredictOn(); // purposefully placed to make tool->GetMTime different than before.
+      QString modelName = m_Controls.modelBox->currentText();
+      if (modelName.startsWith("ensemble", Qt::CaseInsensitive))
+      {
+        this->ProcessEnsembleModelsParams(tool);
+      }
+      else
+      {
+        this->ProcessModelParams(tool);
+      }
+      pythonPathTextItem = m_Controls.pythonEnvComboBox->currentText();
+      QString pythonPath = m_PythonPath;
+      if (!this->IsNNUNetInstalled(pythonPath))
+      {
+        throw std::runtime_error("nnUNet is not detected in the selected python environment. Please select a valid "
+                                 "python environment or install nnUNet.");
+      }
+      tool->SetPythonPath(pythonPath.toStdString());
+      tool->SetModelDirectory(m_ParentFolder->getResultsFolder().toStdString());
+      // checkboxes
+      tool->SetMirror(m_Controls.mirrorBox->isChecked());
+      tool->SetMixedPrecision(m_Controls.mixedPrecisionBox->isChecked());
+      tool->SetNoPip(false);
+      bool doCache = m_Controls.enableCachingCheckBox->isChecked();
+      // Spinboxes
+      tool->SetGpuId(FetchSelectedGPUFromUI());
+      // Multi-Modal
+      tool->MultiModalOff();
+      if (m_Controls.multiModalBox->isChecked())
+      {
+        if (m_Controls.multiModalSpinBox->value() > 0)
+        {
+          tool->m_OtherModalPaths.clear();
+          tool->m_OtherModalPaths = FetchMultiModalImagesFromUI();
+          tool->MultiModalOn();
+        }
+        else
+        {
+          throw std::runtime_error("Please select more than one modalities for a multi-modal task. If you "
+                                   "would like to use only one modality then uncheck the Multi-Modal option.");
+        }
+      }
+      if (doCache)
       {
-        MITK_INFO << "fromJson failed: " << jsonError.errorString().toStdString() << endl;
-        return;
+        hashKey = nnUNetCache::GetUniqueHash(tool->m_ParamQ);
+        if (m_Cache.contains(hashKey))
+        {
+          tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
+        }
       }
-      if (document.isObject())
+      if (tool->GetPredict())
       {
-        QJsonObject jsonObj = document.object();
-        int num_mods = jsonObj["num_modalities"].toInt();
-        ClearAllModalLabels();
-        if (num_mods > 1)
+        tool->m_InputBuffer = nullptr;
+        this->WriteStatusMessage(
+          QString("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>"));
+        tool->UpdatePreview();
+        if (nullptr == tool->GetOutputBuffer())
         {
-          m_Controls.multiModalBox->setChecked(true);
-          m_Controls.multiModalBox->setEnabled(false);
-          m_Controls.multiModalSpinBox->setValue(num_mods - 1);
-          m_Controls.advancedSettingsLayout->update();
-          QJsonObject obj = jsonObj.value("modalities").toObject();
-          QStringList keys = obj.keys();
-          int count = 0;
-          for (auto key : keys)
+          this->SegmentationProcessFailed();
+        }
+        else
+        {
+          this->SegmentationResultHandler(tool);
+          if (doCache)
           {
-            auto value = obj.take(key);
-            QLabel *label = new QLabel("<i>" + value.toString() + "</i>", this);
-            m_ModalLabels.push_back(label);
-            m_Controls.advancedSettingsLayout->addWidget(label, m_UI_ROWS + 1 + count, 0);
-            count++;
+            this->AddToCache(hashKey, tool->GetOutputBuffer());
           }
-          m_Controls.multiModalSpinBox->setMinimum(num_mods - 1);
-          m_Controls.advancedSettingsLayout->update();
+          tool->ClearOutputBuffer();
         }
-        else
+        tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
+      }
+      else
+      {
+        MITK_INFO << "won't do segmentation. Key found: " << QString::number(hashKey).toStdString();
+        if (m_Cache.contains(hashKey))
+        {
+          nnUNetCache *cacheObject = m_Cache[hashKey];
+          MITK_INFO << "fetched pointer " << cacheObject->m_SegCache.GetPointer();
+          tool->SetOutputBuffer(const_cast<mitk::LabelSetImage *>(cacheObject->m_SegCache.GetPointer()));
+          this->SegmentationResultHandler(tool, true);
+        }
+      }
+      m_Controls.previewButton->setEnabled(true);
+    }
+    catch (const std::exception &e)
+    {
+      std::stringstream errorMsg;
+      errorMsg << "<b>STATUS: </b>Error while processing parameters for nnUNet segmentation. Reason: " << e.what();
+      this->ShowErrorMessage(errorMsg.str());
+      this->WriteErrorMessage(QString::fromStdString(errorMsg.str()));
+      m_Controls.previewButton->setEnabled(true);
+      tool->PredictOff();
+      return;
+    }
+    catch (...)
+    {
+      std::string errorMsg = "Unkown error occured while generation nnUNet segmentation.";
+      this->ShowErrorMessage(errorMsg);
+      m_Controls.previewButton->setEnabled(true);
+      tool->PredictOff();
+      return;
+    }
+    if (!pythonPathTextItem.isEmpty())
+    { // only cache if the prediction ended without errors.
+      m_Settings.setValue("nnUNet/LastPythonPath", pythonPathTextItem);
+    }
+  }
+}
+
+void QmitknnUNetToolGUI::OnRefreshPresssed()
+{
+  const QString resultsFolder = m_Controls.modeldirectoryBox->directory();
+  this->OnDirectoryChanged(resultsFolder);
+}
+
+void QmitknnUNetToolGUI::OnDirectoryChanged(const QString &resultsFolder)
+{
+  m_IsResultsFolderValid = false;
+  m_Controls.previewButton->setEnabled(false);
+  this->ClearAllComboBoxes();
+  this->ClearAllModalities();
+  m_ParentFolder = std::make_shared<QmitknnUNetFolderParser>(resultsFolder);
+  auto tasks = m_ParentFolder->getAllTasks<QStringList>();
+  tasks.removeDuplicates();
+  std::for_each(tasks.begin(), tasks.end(), [this](QString task) { m_Controls.taskBox->addItem(task); });
+  m_Settings.setValue("nnUNet/LastRESULTS_FOLDERPath", resultsFolder);
+}
+
+void QmitknnUNetToolGUI::OnModelChanged(const QString &model)
+{
+  if (model.isEmpty())
+  {
+    return;
+  }
+  this->ClearAllModalities();
+  auto selectedTask = m_Controls.taskBox->currentText();
+  ctkComboBox *box = qobject_cast<ctkComboBox *>(sender());
+  if (box == m_Controls.modelBox)
+  {
+    if (model == m_VALID_MODELS.last())
+    {
+      m_Controls.trainerBox->setVisible(false);
+      m_Controls.trainerLabel->setVisible(false);
+      m_Controls.plannerBox->setVisible(false);
+      m_Controls.plannerLabel->setVisible(false);
+      m_Controls.foldBox->setVisible(false);
+      m_Controls.foldLabel->setVisible(false);
+      this->ShowEnsembleLayout(true);
+      auto models = m_ParentFolder->getModelsForTask<QStringList>(m_Controls.taskBox->currentText());
+      models.removeDuplicates();
+      models.removeOne(m_VALID_MODELS.last());
+      for (auto &layout : m_EnsembleParams)
+      {
+        layout->modelBox->clear();
+        layout->trainerBox->clear();
+        layout->plannerBox->clear();
+        std::for_each(models.begin(),
+                      models.end(),
+                      [&layout, this](QString model)
+                      {
+                        if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
+                          layout->modelBox->addItem(model);
+                      });
+      }
+      m_Controls.previewButton->setEnabled(true);
+    }
+    else
+    {
+      m_Controls.trainerBox->setVisible(true);
+      m_Controls.trainerLabel->setVisible(true);
+      m_Controls.plannerBox->setVisible(true);
+      m_Controls.plannerLabel->setVisible(true);
+      m_Controls.foldBox->setVisible(true);
+      m_Controls.foldLabel->setVisible(true);
+      m_Controls.previewButton->setEnabled(false);
+      this->ShowEnsembleLayout(false);
+      auto trainerPlanners = m_ParentFolder->getTrainerPlannersForTask<QStringList>(selectedTask, model);
+      QStringList trainers, planners;
+      std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
+      m_Controls.trainerBox->clear();
+      m_Controls.plannerBox->clear();
+      std::for_each(
+        trainers.begin(), trainers.end(), [this](QString trainer) { m_Controls.trainerBox->addItem(trainer); });
+      std::for_each(
+        planners.begin(), planners.end(), [this](QString planner) { m_Controls.plannerBox->addItem(planner); });
+    }
+  }
+  else if (!m_EnsembleParams.empty())
+  {
+    for (auto &layout : m_EnsembleParams)
+    {
+      if (box == layout->modelBox)
+      {
+        layout->trainerBox->clear();
+        layout->plannerBox->clear();
+        auto trainerPlanners = m_ParentFolder->getTrainerPlannersForTask<QStringList>(selectedTask, model);
+        QStringList trainers, planners;
+        std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
+        std::for_each(trainers.begin(),
+                      trainers.end(),
+                      [&layout](const QString &trainer) { layout->trainerBox->addItem(trainer); });
+        std::for_each(planners.begin(),
+                      planners.end(),
+                      [&layout](const QString &planner) { layout->plannerBox->addItem(planner); });
+        break;
+      }
+    }
+  }
+}
+
+void QmitknnUNetToolGUI::OnTaskChanged(const QString &task)
+{
+  if (task.isEmpty())
+  {
+    return;
+  }
+  m_Controls.modelBox->clear();
+  auto models = m_ParentFolder->getModelsForTask<QStringList>(task);
+  models.removeDuplicates();
+  if (!models.contains(m_VALID_MODELS.last(), Qt::CaseInsensitive))
+  {
+    models << m_VALID_MODELS.last(); // add ensemble even if folder doesn't exist
+  }
+  std::for_each(models.begin(),
+                models.end(),
+                [this](QString model)
+                {
+                  if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
+                    m_Controls.modelBox->addItem(model);
+                });
+}
+
+void QmitknnUNetToolGUI::OnTrainerChanged(const QString &plannerSelected)
+{
+  if (plannerSelected.isEmpty())
+  {
+    return;
+  }
+  m_IsResultsFolderValid = false;
+  QString parentPath;
+  auto *box = qobject_cast<ctkComboBox *>(sender());
+  if (box == m_Controls.plannerBox)
+  {
+    m_Controls.foldBox->clear();
+    auto selectedTrainer = m_Controls.trainerBox->currentText();
+    auto selectedTask = m_Controls.taskBox->currentText();
+    auto selectedModel = m_Controls.modelBox->currentText();
+    auto folds = m_ParentFolder->getFoldsForTrainerPlanner<QStringList>(
+      selectedTrainer, plannerSelected, selectedTask, selectedModel);
+    std::for_each(folds.begin(),
+                  folds.end(),
+                  [this](QString fold)
+                  {
+                    if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
+                      m_Controls.foldBox->addItem(fold);
+                  });
+    if (m_Controls.foldBox->count() != 0)
+    {
+      m_IsResultsFolderValid = true;
+      this->CheckAllInCheckableComboBox(m_Controls.foldBox);
+      auto tempPath = QStringList() << m_ParentFolder->getResultsFolder() << "nnUNet" << selectedModel << selectedTask
+                                    << QString("%1__%2").arg(selectedTrainer, plannerSelected);
+      parentPath = QDir::cleanPath(tempPath.join(QDir::separator()));
+    }
+  }
+  else if (!m_EnsembleParams.empty())
+  {
+    for (auto &layout : m_EnsembleParams)
+    {
+      if (box == layout->plannerBox)
+      {
+        layout->foldBox->clear();
+        auto selectedTrainer = layout->trainerBox->currentText();
+        auto selectedTask = m_Controls.taskBox->currentText();
+        auto selectedModel = layout->modelBox->currentText();
+        auto folds = m_ParentFolder->getFoldsForTrainerPlanner<QStringList>(
+          selectedTrainer, plannerSelected, selectedTask, selectedModel);
+        std::for_each(folds.begin(),
+                      folds.end(),
+                      [&layout](const QString &fold)
+                      {
+                        if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
+                          layout->foldBox->addItem(fold);
+                      });
+        if (layout->foldBox->count() != 0)
+        {
+          this->CheckAllInCheckableComboBox(layout->foldBox);
+          m_IsResultsFolderValid = true;
+          auto tempPath = QStringList() << m_ParentFolder->getResultsFolder() << "nnUNet" << selectedModel
+                                        << selectedTask << QString("%1__%2").arg(selectedTrainer, plannerSelected);
+          parentPath = QDir::cleanPath(tempPath.join(QDir::separator()));
+        }
+        break;
+      }
+    }
+  }
+  if (m_IsResultsFolderValid)
+  {
+    m_Controls.previewButton->setEnabled(true);
+    const QString mitkJsonFile = parentPath + QDir::separator() + m_MITK_EXPORT_JSON_FILENAME;
+    this->DumpAllJSONs(parentPath);
+    if (QFile::exists(mitkJsonFile))
+    {
+      this->DisplayMultiModalInfoFromJSON(mitkJsonFile);
+    }
+    const QString jsonPath = m_ParentFolder->getResultsFolder() + QDir::separator() + m_AVAILABLE_MODELS_JSON_FILENAME;
+    if (QFile::exists(mitkJsonFile))
+    {
+      this->FillAvailableModelsInfoFromJSON(jsonPath);
+    }
+  }
+}
+
+void QmitknnUNetToolGUI::OnPythonPathChanged(const QString &pyEnv)
+{
+  if (pyEnv == QString("Select"))
+  {
+    QString path =
+      QFileDialog::getExistingDirectory(m_Controls.pythonEnvComboBox->parentWidget(), "Python Path", "dir");
+    if (!path.isEmpty())
+    {
+      this->OnPythonPathChanged(path); // recall same function for new path validation
+      m_Controls.pythonEnvComboBox->insertItem(0, path);
+      m_Controls.pythonEnvComboBox->setCurrentIndex(0);
+    }
+  }
+  else if (!this->IsNNUNetInstalled(pyEnv))
+  {
+    std::string warning =
+      "WARNING: nnUNet is not detected on the Python environment you selected. Please select another "
+      "environment or create one. For more info refer https://github.com/MIC-DKFZ/nnUNet";
+    this->ShowErrorMessage(warning);
+    this->DisableEverything();
+  }
+  else
+  {
+    m_Controls.modeldirectoryBox->setEnabled(true);
+    m_Controls.previewButton->setEnabled(true);
+    m_Controls.refreshdirectoryBox->setEnabled(true);
+    m_Controls.multiModalBox->setEnabled(true);
+    QString setVal = this->FetchResultsFolderFromEnv();
+    if (!setVal.isEmpty())
+    {
+      m_Controls.modeldirectoryBox->setDirectory(setVal);
+    }
+    this->OnRefreshPresssed();
+    m_PythonPath = pyEnv.mid(pyEnv.indexOf(" ") + 1);
+    if (!(m_PythonPath.endsWith("bin", Qt::CaseInsensitive) || m_PythonPath.endsWith("bin/", Qt::CaseInsensitive)))
+    {
+      m_PythonPath += QDir::separator() + QString("bin");
+    }
+  }
+}
+
+void QmitknnUNetToolGUI::OnCheckBoxChanged(int state)
+{
+  bool visibility = false;
+  if (state == Qt::Checked)
+  {
+    visibility = true;
+  }
+  ctkCheckBox *box = qobject_cast<ctkCheckBox *>(sender());
+  if (box != nullptr)
+  {
+    if (box->objectName() == QString("multiModalBox"))
+    {
+      m_Controls.multiModalSpinLabel->setVisible(visibility);
+      m_Controls.multiModalSpinBox->setVisible(visibility);
+      if (visibility)
+      {
+        QmitkDataStorageComboBox *defaultImage = new QmitkDataStorageComboBox(this, true);
+        defaultImage->setObjectName(QString("multiModal_" + QString::number(0)));
+        defaultImage->SetPredicate(m_MultiModalPredicate);
+        mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
+        if (tool != nullptr)
         {
-          m_Controls.multiModalSpinBox->setMinimum(0);
-          m_Controls.multiModalBox->setChecked(false);
+          defaultImage->SetDataStorage(tool->GetDataStorage());
+          defaultImage->SetSelectedNode(tool->GetRefNode());
         }
+        m_Controls.advancedSettingsLayout->addWidget(defaultImage, m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
+        m_Modalities.push_back(defaultImage);
+      }
+      else
+      {
+        this->OnModalitiesNumberChanged(0);
+        m_Controls.multiModalSpinBox->setValue(0);
+        delete m_Modalities[0];
+        m_Modalities.pop_back();
+        this->ClearAllModalLabels();
       }
     }
   }
 }
+
+void QmitknnUNetToolGUI::OnModalitiesNumberChanged(int num)
+{
+  while (num > static_cast<int>(m_Modalities.size() - 1))
+  {
+    QmitkDataStorageComboBox *multiModalBox = new QmitkDataStorageComboBox(this, true);
+    mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
+    multiModalBox->SetDataStorage(tool->GetDataStorage());
+    multiModalBox->SetPredicate(m_MultiModalPredicate);
+    multiModalBox->setObjectName(QString("multiModal_" + QString::number(m_Modalities.size() + 1)));
+    m_Controls.advancedSettingsLayout->addWidget(multiModalBox, m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
+    m_Modalities.push_back(multiModalBox);
+  }
+  while (num < static_cast<int>(m_Modalities.size() - 1) && !m_Modalities.empty())
+  {
+    QmitkDataStorageComboBox *child = m_Modalities.back();
+    if (child->objectName() == "multiModal_0")
+    {
+      std::iter_swap(m_Modalities.end() - 2, m_Modalities.end() - 1);
+      child = m_Modalities.back();
+    }
+    delete child; // delete the layout item
+    m_Modalities.pop_back();
+  }
+  m_Controls.advancedSettingsLayout->update();
+}
+
+void QmitknnUNetToolGUI::AutoParsePythonPaths()
+{
+  QString homeDir = QDir::homePath();
+  std::vector<QString> searchDirs;
+#ifdef _WIN32
+  searchDirs.push_back(QString("C:") + QDir::separator() + QString("ProgramData") + QDir::separator() +
+                       QString("anaconda3"));
+#else
+  // Add search locations for possible standard python paths here
+  searchDirs.push_back(homeDir + QDir::separator() + "environments");
+  searchDirs.push_back(homeDir + QDir::separator() + "anaconda3");
+  searchDirs.push_back(homeDir + QDir::separator() + "miniconda3");
+  searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "miniconda3");
+  searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "anaconda3");
+#endif
+  for (QString searchDir : searchDirs)
+  {
+    if (searchDir.endsWith("anaconda3", Qt::CaseInsensitive))
+    {
+      if (QDir(searchDir).exists())
+      {
+        m_Controls.pythonEnvComboBox->insertItem(0, "(base): " + searchDir);
+        searchDir.append((QDir::separator() + QString("envs")));
+      }
+    }
+    for (QDirIterator subIt(searchDir, QDir::AllDirs, QDirIterator::NoIteratorFlags); subIt.hasNext();)
+    {
+      subIt.next();
+      QString envName = subIt.fileName();
+      if (!envName.startsWith('.')) // Filter out irrelevent hidden folders, if any.
+      {
+        m_Controls.pythonEnvComboBox->insertItem(0, "(" + envName + "): " + subIt.filePath());
+      }
+    }
+  }
+  m_Controls.pythonEnvComboBox->setCurrentIndex(-1);
+}
+
+void QmitknnUNetToolGUI::SegmentationProcessFailed()
+{
+  this->WriteErrorMessage(
+    "<b>STATUS: </b><i>Error in the segmentation process. <br>No resulting segmentation can be loaded.</i>");
+  this->setCursor(Qt::ArrowCursor);
+  std::stringstream stream;
+  stream << "Error in the segmentation process. No resulting segmentation can be loaded.";
+  this->ShowErrorMessage(stream.str());
+}
+
+void QmitknnUNetToolGUI::SegmentationResultHandler(mitk::nnUNetTool *tool, bool forceRender)
+{
+  if (forceRender)
+  {
+    tool->RenderOutputBuffer();
+  }
+  this->SetLabelSetPreview(tool->GetPreviewSegmentation());
+  this->WriteStatusMessage("<b>STATUS: </b><i>Segmentation task finished successfully.</i>");
+  this->ActualizePreviewLabelVisibility();
+}
+
+void QmitknnUNetToolGUI::ShowEnsembleLayout(bool visible)
+{
+  if (m_EnsembleParams.empty())
+  {
+    ctkCollapsibleGroupBox *groupBoxModel1 = new ctkCollapsibleGroupBox(this);
+    auto lay1 = std::make_unique<QmitknnUNetTaskParamsUITemplate>(groupBoxModel1);
+    groupBoxModel1->setObjectName(QString::fromUtf8("model_1_Box"));
+    groupBoxModel1->setTitle(QString::fromUtf8("Model 1"));
+    groupBoxModel1->setMinimumSize(QSize(0, 0));
+    groupBoxModel1->setCollapsedHeight(5);
+    groupBoxModel1->setCollapsed(false);
+    groupBoxModel1->setFlat(true);
+    groupBoxModel1->setAlignment(Qt::AlignRight);
+    m_Controls.advancedSettingsLayout->addWidget(groupBoxModel1, 5, 0, 1, 2);
+
+    connect(lay1->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
+    connect(
+      lay1->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
+    m_EnsembleParams.push_back(std::move(lay1));
+
+    ctkCollapsibleGroupBox *groupBoxModel2 = new ctkCollapsibleGroupBox(this);
+    auto lay2 = std::make_unique<QmitknnUNetTaskParamsUITemplate>(groupBoxModel2);
+    groupBoxModel2->setObjectName(QString::fromUtf8("model_2_Box"));
+    groupBoxModel2->setTitle(QString::fromUtf8("Model 2"));
+    groupBoxModel2->setMinimumSize(QSize(0, 0));
+    groupBoxModel2->setCollapsedHeight(5);
+    groupBoxModel2->setCollapsed(false);
+    groupBoxModel2->setFlat(true);
+    groupBoxModel2->setAlignment(Qt::AlignLeft);
+    m_Controls.advancedSettingsLayout->addWidget(groupBoxModel2, 5, 2, 1, 2);
+
+    connect(lay2->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
+    connect(
+      lay2->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
+    m_EnsembleParams.push_back(std::move(lay2));
+  }
+  for (auto &layout : m_EnsembleParams)
+  {
+    layout->setVisible(visible);
+  }
+}
+
+void QmitknnUNetToolGUI::OnDownloadModel()
+{
+  if (m_IsResultsFolderValid)
+  {
+    auto selectedTask = m_Controls.availableBox->currentText();
+    auto spExec = mitk::ProcessExecutor::New();
+    mitk::ProcessExecutor::ArgumentListType args;
+    args.push_back(selectedTask.toStdString());
+    this->WriteStatusMessage(
+      "Downloading the requested task in to the selected Results Folder. This might take some time "
+      "depending on your internet connection...");
+    m_Processes["DOWNLOAD"] = spExec;
+    if (!m_nnUNetThread->isRunning())
+    {
+      MITK_DEBUG << "Starting thread...";
+      m_nnUNetThread->start();
+    }
+    QString resultsFolder = m_ParentFolder->getResultsFolder();
+    emit Operate(resultsFolder, m_PythonPath, spExec, args);
+    m_Controls.stopDownloadButton->setVisible(true);
+    m_Controls.startDownloadButton->setVisible(false);
+  }
+}
+
+void QmitknnUNetToolGUI::OnDownloadWorkerExit(const bool isSuccess, const QString message)
+{
+  if (isSuccess)
+  {
+    this->WriteStatusMessage(message + QString(" Click Refresh Results Folder to use the new Task."));
+  }
+  else
+  {
+    MITK_ERROR << "Download FAILED! " << message.toStdString();
+    this->WriteStatusMessage(QString("Download failed. Check your internet connection. " + message));
+  }
+  m_Controls.stopDownloadButton->setVisible(false);
+  m_Controls.startDownloadButton->setVisible(true);
+}
+
+void QmitknnUNetToolGUI::OnStopDownload()
+{
+  mitk::ProcessExecutor::Pointer spExec = m_Processes["DOWNLOAD"];
+  spExec->KillProcess();
+  this->WriteStatusMessage("Download Killed by the user.");
+  m_Controls.stopDownloadButton->setVisible(false);
+  m_Controls.startDownloadButton->setVisible(true);
+}
+
+void QmitknnUNetToolGUI::OnClearCachePressed()
+{
+  m_Cache.clear();
+  this->UpdateCacheCountOnUI();
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
index 601f36453e..30af8046d3 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
@@ -1,342 +1,403 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.s
 
 ============================================================================*/
 
 #ifndef QmitknnUNetToolGUI_h_Included
 #define QmitknnUNetToolGUI_h_Included
 
-#include "QmitkAutoMLSegmentationToolGUIBase.h"
+#include "QmitkMultiLabelSegWithPreviewToolGUIBase.h"
 #include "QmitknnUNetFolderParser.h"
 #include "QmitknnUNetGPU.h"
+#include "QmitknnUNetWorker.h"
+#include "mitkProcessExecutor.h"
 #include "mitknnUnetTool.h"
 #include "ui_QmitknnUNetToolGUIControls.h"
 #include <MitkSegmentationUIExports.h>
 #include <QCache>
 #include <QMessageBox>
 #include <QSettings>
+#include <QThread>
 #include <QmitkDataStorageComboBox.h>
 #include <QmitknnUNetEnsembleLayout.h>
 #include <boost/functional/hash.hpp>
+#include <unordered_map>
 
 class nnUNetCache
 {
 public:
   mitk::LabelSetImage::ConstPointer m_SegCache;
   static size_t GetUniqueHash(std::vector<mitk::ModelParams> &requestQ)
   {
     size_t hashCode = 0;
     for (mitk::ModelParams &request : requestQ)
     {
       boost::hash_combine(hashCode, request.generateHash());
     }
     return hashCode;
   }
 };
 
-class MITKSEGMENTATIONUI_EXPORT QmitknnUNetToolGUI : public QmitkAutoMLSegmentationToolGUIBase
+class MITKSEGMENTATIONUI_EXPORT QmitknnUNetToolGUI : public QmitkMultiLabelSegWithPreviewToolGUIBase
 {
   Q_OBJECT
 
 public:
-  mitkClassMacro(QmitknnUNetToolGUI, QmitkAutoMLSegmentationToolGUIBase);
+  mitkClassMacro(QmitknnUNetToolGUI, QmitkMultiLabelSegWithPreviewToolGUIBase);
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
   QCache<size_t, nnUNetCache> m_Cache;
 
+  /**
+   * @brief The hash map stores all bifurcating processes' ID.
+   *
+   */
+  std::unordered_map<std::string, mitk::ProcessExecutor::Pointer> m_Processes;
+
 protected slots:
 
   /**
    * @brief Qt slot
    *
    */
   void OnPreviewRequested();
 
   /**
    * @brief Qt slot
    *
    */
-  void OnDirectoryChanged(const QString &);
+  void OnDirectoryChanged(const QString&);
 
   /**
    * @brief Qt slot
    *
    */
-  void OnModelChanged(const QString &);
+  void OnModelChanged(const QString&);
 
   /**
    * @brief Qt slot
    *
    */
   void OnTaskChanged(const QString &);
 
   /**
    * @brief Qt slot
    *
    */
-  void OnTrainerChanged(const QString &);
+  void OnTrainerChanged(const QString&);
 
   /**
    * @brief Qt slot
    *
    */
   void OnCheckBoxChanged(int);
 
   /**
    * @brief Qthread slot to capture failures from thread worker and
    * shows error message
    *
    */
   void SegmentationProcessFailed();
 
   /**
    * @brief Qthread to capture sucessfull nnUNet segmentation.
    * Further, renders the LabelSet image
    */
   void SegmentationResultHandler(mitk::nnUNetTool *, bool forceRender = false);
 
   /**
    * @brief Qt Slot
    *
    */
   void OnModalitiesNumberChanged(int);
 
   /**
    * @brief Qt Slot
    *
    */
-  void OnPythonPathChanged(const QString &);
+  void OnPythonPathChanged(const QString&);
 
   /**
    * @brief Qt slot
    *
    */
   void OnRefreshPresssed();
 
   /**
    * @brief Qt slot
    *
    */
   void OnClearCachePressed();
 
+  /**
+   * @brief Qt slot
+   *
+   */
+  void OnDownloadModel();
+
+  /**
+   * @brief Qt slot
+   *
+   */
+  void OnDownloadWorkerExit(bool, const QString);
+
+  /**
+   * @brief Qt slot
+   *
+   */
+  void OnStopDownload();
+
+signals:
+  /**
+   * @brief signal for starting the segmentation which is caught by a worker thread.
+   */
+  void Operate(QString, QString, mitk::ProcessExecutor::Pointer, mitk::ProcessExecutor::ArgumentListType);
+
 protected:
   QmitknnUNetToolGUI();
-  ~QmitknnUNetToolGUI() = default;
+  ~QmitknnUNetToolGUI();
 
-  void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool *newTool) override;
-  void InitializeUI(QBoxLayout *mainLayout) override;
+  void ConnectNewTool(mitk::SegWithPreviewTool* newTool) override;
+  void InitializeUI(QBoxLayout* mainLayout) override;
   void EnableWidgets(bool enabled) override;
 
 private:
+  /**
+   * @brief Parses the available_models.json file from RESULTS_FOLDER and loads
+   * the task names to the Download combobox in Advanced.
+   */
+  void FillAvailableModelsInfoFromJSON(const QString&);
+
+  /**
+   * @brief Calls other JSON dumping functions.
+   *
+   */
+  void DumpAllJSONs(const QString&);
+
+  /**
+   * @brief Exports available models to download from nnUNet_print_available_pretrained_models
+   * output.
+   */
+  void ExportAvailableModelsAsJSON(const QString&);
 
   /**
    * @brief Clears all displayed modal labels and widgets from GUI.
-   * 
+   *
    */
   void ClearAllModalities();
 
   /**
    * @brief Parses Json file containing modality info and populates
    * labels and selection widgets accordingly on the GUI.
    */
   void DisplayMultiModalInfoFromJSON(const QString&);
 
   /**
-   * @brief Clears all modality labels previously populated from GUI
-   * 
+   * @brief Clears all modality labels previously populated from GUI.
+   *
    */
-
   void ClearAllModalLabels();
 
   /**
    * @brief Runs a set of python commands to read "plans.pkl" and extract
    * modality information required for inferencing. This information is exported
    * as json file : "mitk_export.json".
    *
-   * @return QString 
+   * @return QString
    */
-  QString DumpJSONfromPickle(const QString&);
+  void DumpJSONfromPickle(const QString&);
 
   /**
    * @brief Searches RESULTS_FOLDER environment variable. If not found,
    * returns from the QSettings stored last used path value.
-   * @return QString 
+   * @return QString
    */
   QString FetchResultsFolderFromEnv();
-  
+
   /**
    * @brief Returns GPU id of the selected GPU from the Combo box.
-   * 
-   * @return unsigned int 
+   *
+   * @return unsigned int
    */
   unsigned int FetchSelectedGPUFromUI();
 
   /**
    * @brief Adds GPU information to the gpu combo box.
    * In case, there aren't any GPUs avaialble, the combo box will be
-   * rendered editable. 
+   * rendered editable.
    */
   void SetGPUInfo();
 
   /**
    * @brief Inserts the hash and segmentation into cache and
    * updates count on UI.
    */
   void AddToCache(size_t&, mitk::LabelSetImage::ConstPointer);
-  
+
   /**
    * @brief Checks all the entries of the ctkCheckableComboBox ui widget.
    * This feature is not present in ctkCheckableComboBox API.
    */
-  void CheckAllInCheckableComboBox(ctkCheckableComboBox *);
+  void CheckAllInCheckableComboBox(ctkCheckableComboBox*);
 
   /**
    * @brief Parses the folder names containing trainer and planner together and,
    * returns it as separate lists.
    * @return std::pair<QStringList, QStringList>
    */
 
   std::pair<QStringList, QStringList> ExtractTrainerPlannerFromString(QStringList);
   /**
    * @brief Parses the ensemble UI elements and sets to nnUNetTool object pointer.
    *
    */
   void ProcessEnsembleModelsParams(mitk::nnUNetTool::Pointer);
 
   /**
    * @brief Parses the UI elements and sets to nnUNetTool object pointer.
    *
    */
   void ProcessModelParams(mitk::nnUNetTool::Pointer);
 
   /**
    * @brief Creates and renders QmitknnUNetTaskParamsUITemplate layout for ensemble input.
    */
   void ShowEnsembleLayout(bool visible = true);
 
   /**
    * @brief Creates a QMessage object and shows on screen.
    */
-  void ShowErrorMessage(const std::string &, QMessageBox::Icon = QMessageBox::Critical);
+  void ShowErrorMessage(const std::string&, QMessageBox::Icon = QMessageBox::Critical);
 
   /**
    * @brief Writes any message in white on the tool pane.
    */
-  void WriteStatusMessage(const QString &);
-  
+  void WriteStatusMessage(const QString&);
+
   /**
    * @brief Writes any message in red on the tool pane.
    */
-  void WriteErrorMessage(const QString &);
+  void WriteErrorMessage(const QString&);
 
   /**
    * @brief Searches and parses paths of python virtual enviroments
    * from predefined lookout locations
    */
   void AutoParsePythonPaths();
 
   /**
    * @brief Check if pretrained model sub folder inside RESULTS FOLDER exist.
    */
-  bool IsModelExists(const QString &, const QString &, const QString &);
+  bool IsModelExists(const QString&, const QString&, const QString&);
 
   /**
    * @brief Clears all combo boxes
    * Any new combo box added in the future can be featured here for clearance.
    *
    */
   void ClearAllComboBoxes();
 
   /**
    * @brief Disable/deactivates the nnUNet GUI.
    * Clears any multi modal labels and selection widgets, as well.
    */
   void DisableEverything();
 
   /**
    * @brief Checks if nnUNet_predict command is valid in the selected python virtual environment.
    *
    * @return bool
    */
-  bool IsNNUNetInstalled(const QString &);
+  bool IsNNUNetInstalled(const QString&);
 
   /**
    * @brief Mapper function to map QString entries from UI to ModelParam attributes.
    *
    * @return mitk::ModelParams
    */
   mitk::ModelParams MapToRequest(
-    const QString &, const QString &, const QString &, const QString &, const std::vector<std::string> &);
+    const QString&, const QString&, const QString&, const QString&, const std::vector<std::string>&);
 
   /**
    * @brief Returns checked fold names from the ctk-Checkable-ComboBox.
    *
    * @return std::vector<std::string>
    */
-  std::vector<std::string> FetchSelectedFoldsFromUI(ctkCheckableComboBox *);
+  std::vector<std::string> FetchSelectedFoldsFromUI(ctkCheckableComboBox*);
 
   /**
    * @brief Returns all paths from the dynamically generated ctk-path-line-edit boxes.
    *
    * @return std::vector<std::string>
    */
   std::vector<mitk::Image::ConstPointer> FetchMultiModalImagesFromUI();
 
   /**
    * @brief Updates cache count on UI.
-   * 
+   *
    */
   void UpdateCacheCountOnUI();
 
   Ui_QmitknnUNetToolGUIControls m_Controls;
   QmitkGPULoader m_GpuLoader;
 
   /**
    * @brief Stores all dynamically added ctk-path-line-edit UI elements.
    *
    */
-  std::vector<QmitkDataStorageComboBox *> m_Modalities;
+  std::vector<QmitkDataStorageComboBox*> m_Modalities;
   std::vector<QLabel*> m_ModalLabels;
 
   std::vector<std::unique_ptr<QmitknnUNetTaskParamsUITemplate>> m_EnsembleParams;
 
   mitk::NodePredicateBase::Pointer m_MultiModalPredicate;
 
   QString m_PythonPath;
 
   /**
    * @brief Stores row count of the "advancedSettingsLayout" layout element. This value helps dynamically add
    * ctk-path-line-edit UI elements at the right place. Forced to initialize in the InitializeUI method since there is
    * no guarantee of retrieving exact row count anywhere else.
    *
    */
   int m_UI_ROWS;
 
   /**
    * @brief Stores path of the model director (RESULTS_FOLDER appended by "nnUNet").
    *
    */
   std::shared_ptr<QmitknnUNetFolderParser> m_ParentFolder = nullptr;
 
   /**
    * @brief Valid list of models supported by nnUNet
    *
    */
   const QStringList m_VALID_MODELS = {"2d", "3d_lowres", "3d_fullres", "3d_cascade_fullres", "ensembles"};
 
   const QString m_CACHE_COUNT_BASE_LABEL = "Cached Items: ";
 
+  const QString m_MITK_EXPORT_JSON_FILENAME = "mitk_export.json";
+
+  const QString m_AVAILABLE_MODELS_JSON_FILENAME = "available_models.json";
+
+  const QString m_PICKLE_FILENAME = "plans.pkl";
+
   /**
    * @brief For storing values across sessions. Currently, RESULTS_FOLDER value is cached using this.
    */
   QSettings m_Settings;
+
+  bool m_IsResultsFolderValid = false;
+
+  QThread* m_nnUNetThread;
+  nnUNetDownloadWorker* m_Worker;
 };
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
index a3d0a1ce7f..2eaed4a5b1 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
@@ -1,439 +1,469 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitknnUNetToolGUIControls</class>
  <widget class="QWidget" name="QmitknnUNetToolGUIControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>877</width>
     <height>711</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Ignored" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
     <width>100</width>
     <height>0</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>100000</width>
     <height>100000</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitknnUNetToolWidget</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="leftMargin">
     <number>0</number>
    </property>
    <property name="topMargin">
     <number>0</number>
    </property>
    <property name="rightMargin">
     <number>0</number>
    </property>
    <property name="bottomMargin">
     <number>0</number>
    </property>
    <item>
     <layout class="QGridLayout" name="advancedSettingsLayout">
      <item row="5" column="3">
       <widget class="ctkComboBox" name="plannerBox"/>
      </item>
      <item row="5" column="1">
       <widget class="ctkComboBox" name="trainerBox"/>
      </item>
      <item row="3" column="1" colspan="3">
       <widget class="QPushButton" name="refreshdirectoryBox">
        <property name="text">
         <string>Refresh Results Folder</string>
        </property>
       </widget>
      </item>
      <item row="1" column="0">
       <widget class="QLabel" name="pythonEnvLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Python Path:</string>
        </property>
       </widget>
      </item>
      <item row="5" column="2">
       <widget class="QLabel" name="plannerLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Plan:</string>
        </property>
       </widget>
      </item>
      <item row="5" column="0">
       <widget class="QLabel" name="trainerLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Trainer:</string>
        </property>
       </widget>
      </item>
      <item row="2" column="0">
       <widget class="QLabel" name="pretraineddirLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>nnUNet Results Folder:</string>
        </property>
       </widget>
      </item>
      <item row="4" column="1">
       <widget class="ctkComboBox" name="taskBox"/>
      </item>
      <item row="7" column="1">
       <widget class="ctkCheckBox" name="multiModalBox"/>
      </item>
      <item row="7" column="0">
       <widget class="QLabel" name="multiModalLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Multi-Modal:</string>
        </property>
       </widget>
      </item>
      <item row="0" column="0" colspan="4">
       <widget class="QLabel" name="welcomeNote">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Welcome to nnUNet in MITK. [Experimental]&lt;/p&gt;&lt;p&gt;Please note that this is only an interface to nnUNet. MITK does not ship with nnUNet. Make sure to have a working Python environment with nnUNet set up beforehand. Choose that environment in the Python Path before inferencing. &lt;/p&gt;&lt;p&gt;Refer to &lt;a href=&quot;https://github.com/MIC-DKFZ/nnUNet&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;https://github.com/MIC-DKFZ/nnUNet&lt;/span&gt;&lt;/a&gt; to learn everything about the nnUNet.&lt;/p&gt;&lt;p&gt;Also, note that if multiple Preview objects are selected to Confirm, they will be merged. &lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
        </property>
        <property name="textFormat">
         <enum>Qt::RichText</enum>
        </property>
        <property name="wordWrap">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item row="2" column="1" colspan="3">
       <widget class="ctkDirectoryButton" name="modeldirectoryBox" native="true"/>
      </item>
      <item row="4" column="2">
       <widget class="QLabel" name="modelLabel">
        <property name="text">
         <string>Configuration:</string>
        </property>
       </widget>
      </item>
      <item row="4" column="3">
       <widget class="ctkComboBox" name="modelBox"/>
      </item>
      <item row="4" column="0">
       <widget class="QLabel" name="taskLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Task:</string>
        </property>
       </widget>
      </item>
      <item row="6" column="1">
       <widget class="ctkCheckableComboBox" name="foldBox"/>
      </item>
      <item row="7" column="2">
       <widget class="QLabel" name="multiModalSpinLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>No. of Extra Modalities:</string>
        </property>
       </widget>
      </item>
      <item row="6" column="0">
       <widget class="QLabel" name="foldLabel">
        <property name="text">
         <string>Fold:</string>
        </property>
       </widget>
      </item>
      <item row="1" column="1" colspan="3">
       <widget class="ctkComboBox" name="pythonEnvComboBox"/>
      </item>
      <item row="7" column="3">
       <widget class="QSpinBox" name="multiModalSpinBox"/>
      </item>
     </layout>
    </item>
    <item>
     <widget class="ctkCollapsibleGroupBox" name="inputGroupBox">
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>0</height>
       </size>
      </property>
      <property name="title">
       <string>Advanced</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignRight</set>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <property name="collapsedHeight" stdset="0">
       <number>5</number>
      </property>
      <property name="collapsed" stdset="0">
       <bool>true</bool>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_4">
       <item>
        <layout class="QGridLayout" name="_2">
         <property name="leftMargin">
          <number>0</number>
         </property>
         <property name="topMargin">
          <number>0</number>
         </property>
         <property name="rightMargin">
          <number>0</number>
         </property>
         <property name="bottomMargin">
          <number>0</number>
         </property>
         <property name="spacing">
          <number>6</number>
         </property>
         <item row="0" column="2">
          <widget class="QLabel" name="mixedPrecisionLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Mixed Precision:</string>
           </property>
          </widget>
         </item>
         <item row="0" column="3">
          <widget class="QCheckBox" name="mixedPrecisionBox">
           <property name="checked">
            <bool>true</bool>
           </property>
          </widget>
         </item>
         <item row="1" column="0">
          <widget class="QLabel" name="gpuSpinLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>GPU Id:</string>
           </property>
          </widget>
         </item>
         <item row="1" column="1">
          <widget class="ctkComboBox" name="gpuComboBox"/>
         </item>
         <item row="1" column="2">
          <widget class="QLabel" name="mirrorLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Enable Mirroring:</string>
           </property>
          </widget>
         </item>
         <item row="1" column="3">
          <widget class="ctkCheckBox" name="mirrorBox">
           <property name="checked">
            <bool>true</bool>
           </property>
          </widget>
         </item>
         <item row="0" column="0">
          <widget class="QLabel" name="postProcessingLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Use Postprocessing JSON:</string>
           </property>
          </widget>
         </item>
         <item row="0" column="1">
          <widget class="ctkCheckBox" name="postProcessingCheckBox">
           <property name="checked">
            <bool>true</bool>
           </property>
          </widget>
         </item>
         <item row="5" column="0">
          <widget class="QLabel" name="enableCachingLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Enable Caching:</string>
           </property>
          </widget>
         </item>
         <item row="5" column="1">
          <widget class="ctkCheckBox" name="enableCachingCheckBox">
           <property name="checked">
            <bool>true</bool>
           </property>
          </widget>
         </item>
         <item row="5" column="2">
          <widget class="QPushButton" name="clearCacheButton">
           <property name="text">
            <string>Clear Cache</string>
           </property>
          </widget>
         </item>
         <item row="5" column="3">
          <widget class="QLabel" name="cacheCountLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Cached Items: 0</string>
           </property>
          </widget>
         </item>
+        <item row="6" column="0">
+         <widget class="QLabel" name="AvailableModelsLabel">
+          <property name="sizePolicy">
+            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Available Models:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="6" column="1" colspan="2">
+         <widget class="ctkComboBox" name="availableBox" native="true"/>
+        </item>
+        <item row="6" column="3">
+         <widget class="QPushButton" name="startDownloadButton">
+          <property name="text">
+           <string>Download</string>
+          </property>
+         </widget>
+        </item>
+        <item row="6" column="3">
+          <widget class="QPushButton" name="stopDownloadButton">
+           <property name="text">
+            <string>Stop</string>
+           </property>
+          </widget>
+         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QPushButton" name="previewButton">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="maximumSize">
       <size>
        <width>100000</width>
        <height>16777215</height>
       </size>
      </property>
      <property name="text">
       <string>Preview</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QLabel" name="statusLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>ctkDirectoryButton</class>
    <extends>QWidget</extends>
    <header location="global">ctkDirectoryButton.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>ctkComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">ctkComboBox.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>ctkCheckableComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">ctkCheckableComboBox.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>ctkCheckBox</class>
    <extends>QCheckBox</extends>
    <header location="global">ctkCheckBox.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>ctkCollapsibleGroupBox</class>
    <extends>QGroupBox</extends>
    <header location="global">ctkCollapsibleGroupBox.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
deleted file mode 100644
index 4b82f39ed2..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
+++ /dev/null
@@ -1,478 +0,0 @@
-#include "QmitknnUNetToolGUI.h"
-#include <QDir>
-#include <QDirIterator>
-#include <QmitknnUNetEnsembleLayout.h>
-#include <algorithm>
-#include <ctkCollapsibleGroupBox.h>
-
-void QmitknnUNetToolGUI::EnableWidgets(bool enabled)
-{
-  Superclass::EnableWidgets(enabled);
-}
-
-void QmitknnUNetToolGUI::ClearAllModalities()
-{
-  m_Controls.multiModalSpinBox->setMinimum(0);
-  m_Controls.multiModalBox->setChecked(false);
-  ClearAllModalLabels();
-}
-
-void QmitknnUNetToolGUI::ClearAllModalLabels()
-{
-  for (auto modalLabel : m_ModalLabels)
-  {
-    delete modalLabel; // delete the layout item
-    m_ModalLabels.pop_back();
-  }
-  m_Controls.advancedSettingsLayout->update();
-}
-
-void QmitknnUNetToolGUI::DisableEverything()
-{
-  m_Controls.modeldirectoryBox->setEnabled(false);
-  m_Controls.refreshdirectoryBox->setEnabled(false);
-  m_Controls.previewButton->setEnabled(false);
-  m_Controls.multiModalSpinBox->setVisible(false);
-  m_Controls.multiModalBox->setEnabled(false);
-  ClearAllComboBoxes();
-  ClearAllModalities();
-}
-
-void QmitknnUNetToolGUI::ClearAllComboBoxes()
-{
-  m_Controls.modelBox->clear();
-  m_Controls.taskBox->clear();
-  m_Controls.foldBox->clear();
-  m_Controls.trainerBox->clear();
-  m_Controls.plannerBox->clear();
-  for (auto &layout : m_EnsembleParams)
-  {
-    layout->modelBox->clear();
-    layout->trainerBox->clear();
-    layout->plannerBox->clear();
-    layout->foldBox->clear();
-  }
-}
-
-void QmitknnUNetToolGUI::OnRefreshPresssed()
-{
-  const QString resultsFolder = m_Controls.modeldirectoryBox->directory();
-  OnDirectoryChanged(resultsFolder);
-}
-
-void QmitknnUNetToolGUI::OnDirectoryChanged(const QString &resultsFolder)
-{
-  m_Controls.previewButton->setEnabled(false);
-  ClearAllComboBoxes();
-  ClearAllModalities();
-  m_ParentFolder = std::make_shared<QmitknnUNetFolderParser>(resultsFolder);
-  auto tasks = m_ParentFolder->getAllTasks<QStringList>();
-  tasks.removeDuplicates();
-  std::for_each(tasks.begin(), tasks.end(), [this](QString task) { m_Controls.taskBox->addItem(task); });
-  m_Settings.setValue("nnUNet/LastRESULTS_FOLDERPath", resultsFolder);
-}
-
-void QmitknnUNetToolGUI::OnModelChanged(const QString &model)
-{
-  if (model.isEmpty())
-  {
-    return;
-  }
-  ClearAllModalities();
-  auto selectedTask = m_Controls.taskBox->currentText();
-  ctkComboBox *box = qobject_cast<ctkComboBox *>(sender());
-  if (box == m_Controls.modelBox)
-  {
-    if (model == m_VALID_MODELS.last())
-    {
-      m_Controls.trainerBox->setVisible(false);
-      m_Controls.trainerLabel->setVisible(false);
-      m_Controls.plannerBox->setVisible(false);
-      m_Controls.plannerLabel->setVisible(false);
-      m_Controls.foldBox->setVisible(false);
-      m_Controls.foldLabel->setVisible(false);
-      ShowEnsembleLayout(true);
-      auto models = m_ParentFolder->getModelsForTask<QStringList>(m_Controls.taskBox->currentText());
-      models.removeDuplicates();
-      models.removeOne(m_VALID_MODELS.last());
-      for (auto &layout : m_EnsembleParams)
-      {
-        layout->modelBox->clear();
-        layout->trainerBox->clear();
-        layout->plannerBox->clear();
-        std::for_each(models.begin(),
-                      models.end(),
-                      [&layout, this](QString model)
-                      {
-                        if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
-                          layout->modelBox->addItem(model);
-                      });
-      }
-      m_Controls.previewButton->setEnabled(true);
-    }
-    else
-    {
-      m_Controls.trainerBox->setVisible(true);
-      m_Controls.trainerLabel->setVisible(true);
-      m_Controls.plannerBox->setVisible(true);
-      m_Controls.plannerLabel->setVisible(true);
-      m_Controls.foldBox->setVisible(true);
-      m_Controls.foldLabel->setVisible(true);
-      m_Controls.previewButton->setEnabled(false);
-      ShowEnsembleLayout(false);
-      auto trainerPlanners = m_ParentFolder->getTrainerPlannersForTask<QStringList>(selectedTask, model);
-      QStringList trainers, planners;
-      std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
-      m_Controls.trainerBox->clear();
-      m_Controls.plannerBox->clear();
-      std::for_each(
-        trainers.begin(), trainers.end(), [this](QString trainer) { m_Controls.trainerBox->addItem(trainer); });
-      std::for_each(
-        planners.begin(), planners.end(), [this](QString planner) { m_Controls.plannerBox->addItem(planner); });
-    }
-  }
-  else if (!m_EnsembleParams.empty())
-  {
-    for (auto &layout : m_EnsembleParams)
-    {
-      if (box == layout->modelBox)
-      {
-        layout->trainerBox->clear();
-        layout->plannerBox->clear();
-        auto trainerPlanners = m_ParentFolder->getTrainerPlannersForTask<QStringList>(selectedTask, model);
-        QStringList trainers, planners;
-        std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
-        std::for_each(trainers.begin(),
-                      trainers.end(),
-                      [&layout](const QString &trainer) { layout->trainerBox->addItem(trainer); });
-        std::for_each(planners.begin(),
-                      planners.end(),
-                      [&layout](const QString &planner) { layout->plannerBox->addItem(planner); });
-        break;
-      }
-    }
-  }
-}
-
-void QmitknnUNetToolGUI::OnTaskChanged(const QString &task)
-{
-  if (task.isEmpty())
-  {
-    return;
-  }
-  m_Controls.modelBox->clear();
-  auto models = m_ParentFolder->getModelsForTask<QStringList>(task);
-  models.removeDuplicates();
-  if (!models.contains(m_VALID_MODELS.last(), Qt::CaseInsensitive))
-  {
-    models << m_VALID_MODELS.last(); // add ensemble even if folder doesn't exist
-  }
-  std::for_each(models.begin(),
-                models.end(),
-                [this](QString model)
-                {
-                  if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
-                    m_Controls.modelBox->addItem(model);
-                });
-}
-
-void QmitknnUNetToolGUI::OnTrainerChanged(const QString &plannerSelected)
-{
-  if (plannerSelected.isEmpty())
-  {
-    return;
-  }
-  auto *box = qobject_cast<ctkComboBox *>(sender());
-  if (box == m_Controls.plannerBox)
-  {
-    m_Controls.foldBox->clear();
-    auto selectedTrainer = m_Controls.trainerBox->currentText();
-    auto selectedTask = m_Controls.taskBox->currentText();
-    auto selectedModel = m_Controls.modelBox->currentText();
-    auto folds = m_ParentFolder->getFoldsForTrainerPlanner<QStringList>(
-      selectedTrainer, plannerSelected, selectedTask, selectedModel);
-    std::for_each(folds.begin(),
-                  folds.end(),
-                  [this](QString fold)
-                  {
-                    if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
-                      m_Controls.foldBox->addItem(fold);
-                  });
-    if (m_Controls.foldBox->count() != 0)
-    {
-      CheckAllInCheckableComboBox(m_Controls.foldBox);
-      m_Controls.previewButton->setEnabled(true);
-      const QString parentPath = QDir::cleanPath(m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" +
-                                                 QDir::separator() + selectedModel + QDir::separator() + selectedTask +
-                                                 QDir::separator() + selectedTrainer + QString("__") + plannerSelected);
-      const QString jsonPath = this->DumpJSONfromPickle(parentPath);
-      if (!jsonPath.isEmpty())
-      {
-        this->DisplayMultiModalInfoFromJSON(jsonPath);
-      }
-    }
-  }
-  else if (!m_EnsembleParams.empty())
-  {
-    for (auto &layout : m_EnsembleParams)
-    {
-      if (box == layout->plannerBox)
-      {
-        layout->foldBox->clear();
-        auto selectedTrainer = layout->trainerBox->currentText();
-        auto selectedTask = m_Controls.taskBox->currentText();
-        auto selectedModel = layout->modelBox->currentText();
-        auto folds = m_ParentFolder->getFoldsForTrainerPlanner<QStringList>(
-          selectedTrainer, plannerSelected, selectedTask, selectedModel);
-        std::for_each(folds.begin(),
-                      folds.end(),
-                      [&layout](const QString &fold)
-                      {
-                        if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
-                          layout->foldBox->addItem(fold);
-                      });
-        if (layout->foldBox->count() != 0)
-        {
-          CheckAllInCheckableComboBox(layout->foldBox);
-          m_Controls.previewButton->setEnabled(true);
-          const QString parentPath = QDir::cleanPath(
-            m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + selectedModel +
-            QDir::separator() + selectedTask + QDir::separator() + selectedTrainer + QString("__") + plannerSelected);
-          const QString jsonPath = this->DumpJSONfromPickle(parentPath);
-          if (!jsonPath.isEmpty())
-          {
-            this->DisplayMultiModalInfoFromJSON(jsonPath);
-          }
-        }
-        break;
-      }
-    }
-  }
-}
-
-void QmitknnUNetToolGUI::OnPythonPathChanged(const QString &pyEnv)
-{
-  if (pyEnv == QString("Select"))
-  {
-    QString path =
-      QFileDialog::getExistingDirectory(m_Controls.pythonEnvComboBox->parentWidget(), "Python Path", "dir");
-    if (!path.isEmpty())
-    {
-      OnPythonPathChanged(path); // recall same function for new path validation
-      m_Controls.pythonEnvComboBox->insertItem(0, path);
-      m_Controls.pythonEnvComboBox->setCurrentIndex(0);
-    }
-  }
-  else if (!IsNNUNetInstalled(pyEnv))
-  {
-    std::string warning =
-      "WARNING: nnUNet is not detected on the Python environment you selected. Please select another "
-      "environment or create one. For more info refer https://github.com/MIC-DKFZ/nnUNet";
-    ShowErrorMessage(warning);
-    DisableEverything();
-  }
-  else
-  {
-    m_Controls.modeldirectoryBox->setEnabled(true);
-    m_Controls.previewButton->setEnabled(true);
-    m_Controls.refreshdirectoryBox->setEnabled(true);
-    m_Controls.multiModalBox->setEnabled(true);
-    QString setVal = FetchResultsFolderFromEnv();
-    if (!setVal.isEmpty())
-    {
-      m_Controls.modeldirectoryBox->setDirectory(setVal);
-    }
-    OnRefreshPresssed();
-    m_PythonPath = pyEnv.mid(pyEnv.indexOf(" ") + 1);
-    if (!(m_PythonPath.endsWith("bin", Qt::CaseInsensitive) || m_PythonPath.endsWith("bin/", Qt::CaseInsensitive)))
-    {
-      m_PythonPath += QDir::separator() + QString("bin");
-    }
-  }
-}
-
-void QmitknnUNetToolGUI::OnCheckBoxChanged(int state)
-{
-  bool visibility = false;
-  if (state == Qt::Checked)
-  {
-    visibility = true;
-  }
-  ctkCheckBox *box = qobject_cast<ctkCheckBox *>(sender());
-  if (box != nullptr)
-  {
-    if (box->objectName() == QString("multiModalBox"))
-    {
-      m_Controls.multiModalSpinLabel->setVisible(visibility);
-      m_Controls.multiModalSpinBox->setVisible(visibility);
-      if (visibility)
-      {
-        QmitkDataStorageComboBox *defaultImage = new QmitkDataStorageComboBox(this, true);
-        defaultImage->setObjectName(QString("multiModal_" + QString::number(0)));
-        defaultImage->SetPredicate(m_MultiModalPredicate);
-        mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
-        if (tool != nullptr)
-        {
-          defaultImage->SetDataStorage(tool->GetDataStorage());
-          defaultImage->SetSelectedNode(tool->GetRefNode());
-        }
-        m_Controls.advancedSettingsLayout->addWidget(defaultImage, m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
-        m_Modalities.push_back(defaultImage);
-      }
-      else
-      {
-        OnModalitiesNumberChanged(0);
-        m_Controls.multiModalSpinBox->setValue(0);
-        delete m_Modalities[0];
-        m_Modalities.pop_back();
-        ClearAllModalLabels();
-      }
-    }
-  }
-}
-
-void QmitknnUNetToolGUI::OnModalitiesNumberChanged(int num)
-{
-  while (num > static_cast<int>(m_Modalities.size() - 1))
-  {
-    QmitkDataStorageComboBox *multiModalBox = new QmitkDataStorageComboBox(this, true);
-    mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
-    multiModalBox->SetDataStorage(tool->GetDataStorage());
-    multiModalBox->SetPredicate(m_MultiModalPredicate);
-    multiModalBox->setObjectName(QString("multiModal_" + QString::number(m_Modalities.size() + 1)));
-    m_Controls.advancedSettingsLayout->addWidget(multiModalBox, m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
-    m_Modalities.push_back(multiModalBox);
-  }
-  while (num < static_cast<int>(m_Modalities.size() - 1) && !m_Modalities.empty())
-  {
-    QmitkDataStorageComboBox *child = m_Modalities.back();
-    if (child->objectName() == "multiModal_0")
-    {
-      std::iter_swap(m_Modalities.end() - 2, m_Modalities.end() - 1);
-      child = m_Modalities.back();
-    }
-    delete child; // delete the layout item
-    m_Modalities.pop_back();
-  }
-  m_Controls.advancedSettingsLayout->update();
-}
-
-void QmitknnUNetToolGUI::AutoParsePythonPaths()
-{
-  QString homeDir = QDir::homePath();
-  std::vector<QString> searchDirs;
-#ifdef _WIN32
-  searchDirs.push_back(QString("C:") + QDir::separator() + QString("ProgramData") + QDir::separator() +
-                       QString("anaconda3"));
-#else
-  // Add search locations for possible standard python paths here
-  searchDirs.push_back(homeDir + QDir::separator() + "environments");
-  searchDirs.push_back(homeDir + QDir::separator() + "anaconda3");
-  searchDirs.push_back(homeDir + QDir::separator() + "miniconda3");
-  searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "miniconda3");
-  searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "anaconda3");
-#endif
-  for (QString searchDir : searchDirs)
-  {
-    if (searchDir.endsWith("anaconda3", Qt::CaseInsensitive))
-    {
-      if (QDir(searchDir).exists())
-      {
-        m_Controls.pythonEnvComboBox->insertItem(0, "(base): " + searchDir);
-        searchDir.append((QDir::separator() + QString("envs")));
-      }
-    }
-    for (QDirIterator subIt(searchDir, QDir::AllDirs, QDirIterator::NoIteratorFlags); subIt.hasNext();)
-    {
-      subIt.next();
-      QString envName = subIt.fileName();
-      if (!envName.startsWith('.')) // Filter out irrelevent hidden folders, if any.
-      {
-        m_Controls.pythonEnvComboBox->insertItem(0, "(" + envName + "): " + subIt.filePath());
-      }
-    }
-  }
-  m_Controls.pythonEnvComboBox->setCurrentIndex(-1);
-}
-
-mitk::ModelParams QmitknnUNetToolGUI::MapToRequest(const QString &modelName,
-                                                   const QString &taskName,
-                                                   const QString &trainer,
-                                                   const QString &planId,
-                                                   const std::vector<std::string> &folds)
-{
-  mitk::ModelParams requestObject;
-  requestObject.model = modelName.toStdString();
-  requestObject.trainer = trainer.toStdString();
-  requestObject.planId = planId.toStdString();
-  requestObject.task = taskName.toStdString();
-  requestObject.folds = folds;
-  mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
-  requestObject.inputName = tool->GetRefNode()->GetName();
-  requestObject.timeStamp =
-    std::to_string(mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint());
-  return requestObject;
-}
-
-void QmitknnUNetToolGUI::SegmentationProcessFailed()
-{
-  WriteErrorMessage(
-    "<b>STATUS: </b><i>Error in the segmentation process. <br>No resulting segmentation can be loaded.</i>");
-  this->setCursor(Qt::ArrowCursor);
-  std::stringstream stream;
-  stream << "Error in the segmentation process. No resulting segmentation can be loaded.";
-  ShowErrorMessage(stream.str());
-}
-
-void QmitknnUNetToolGUI::SegmentationResultHandler(mitk::nnUNetTool *tool, bool forceRender)
-{
-  if (forceRender)
-  {
-    tool->RenderOutputBuffer();
-  }
-  this->SetLabelSetPreview(tool->GetMLPreview());
-  WriteStatusMessage("<b>STATUS: </b><i>Segmentation task finished successfully. <br> If multiple Preview objects are selected to Confirm, "
-  "they will be merged. Any unselected Preview objects will be lost.</i>");
-}
-
-void QmitknnUNetToolGUI::ShowEnsembleLayout(bool visible)
-{
-  if (m_EnsembleParams.empty())
-  {
-    ctkCollapsibleGroupBox *groupBoxModel1 = new ctkCollapsibleGroupBox(this);
-    auto lay1 = std::make_unique<QmitknnUNetTaskParamsUITemplate>(groupBoxModel1);
-    groupBoxModel1->setObjectName(QString::fromUtf8("model_1_Box"));
-    groupBoxModel1->setTitle(QString::fromUtf8("Model 1"));
-    groupBoxModel1->setMinimumSize(QSize(0, 0));
-    groupBoxModel1->setCollapsedHeight(5);
-    groupBoxModel1->setCollapsed(false);
-    groupBoxModel1->setFlat(true);
-    groupBoxModel1->setAlignment(Qt::AlignRight);
-    m_Controls.advancedSettingsLayout->addWidget(groupBoxModel1, 5, 0, 1, 2);
-
-    connect(lay1->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
-    connect(
-      lay1->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
-    m_EnsembleParams.push_back(std::move(lay1));
-
-    ctkCollapsibleGroupBox *groupBoxModel2 = new ctkCollapsibleGroupBox(this);
-    auto lay2 = std::make_unique<QmitknnUNetTaskParamsUITemplate>(groupBoxModel2);
-    groupBoxModel2->setObjectName(QString::fromUtf8("model_2_Box"));
-    groupBoxModel2->setTitle(QString::fromUtf8("Model 2"));
-    groupBoxModel2->setMinimumSize(QSize(0, 0));
-    groupBoxModel2->setCollapsedHeight(5);
-    groupBoxModel2->setCollapsed(false);
-    groupBoxModel2->setFlat(true);
-    groupBoxModel2->setAlignment(Qt::AlignLeft);
-    m_Controls.advancedSettingsLayout->addWidget(groupBoxModel2, 5, 2, 1, 2);
-
-    connect(lay2->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
-    connect(
-      lay2->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
-    m_EnsembleParams.push_back(std::move(lay2));
-  }
-  for (auto &layout : m_EnsembleParams)
-  {
-    layout->setVisible(visible);
-  }
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetWorker.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetWorker.cpp
new file mode 100644
index 0000000000..8fb9897153
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetWorker.cpp
@@ -0,0 +1,26 @@
+#include "QmitknnUNetWorker.h"
+
+#include "mitkRenderingManager.h"
+#include <QMutexLocker>
+#include <itksys/SystemTools.hxx>
+
+void nnUNetDownloadWorker::DoWork(QString resultsFolder,
+                                  QString pythonPath,
+                                  mitk::ProcessExecutor::Pointer spExec,
+                                  mitk::ProcessExecutor::ArgumentListType args)
+{
+  MITK_INFO << "in nnUNet Worker";
+  try
+  {
+    QMutexLocker locker(&mutex);
+    std::string resultsFolderEnv = "RESULTS_FOLDER=" + resultsFolder.toStdString();
+    itksys::SystemTools::PutEnv(resultsFolderEnv.c_str());
+    spExec->Execute(pythonPath.toStdString(), "nnUNet_download_pretrained_model", args);
+    MITK_INFO << "in nnUNet Worker: download finished";
+    emit Exit(true, QString("Download completed successfully."));
+  }
+  catch (const mitk::Exception &e)
+  {
+    emit Exit(false, QString::fromStdString(e.GetDescription()));
+  }
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetWorker.h b/Modules/SegmentationUI/Qmitk/QmitknnUNetWorker.h
new file mode 100644
index 0000000000..fe00b728f4
--- /dev/null
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetWorker.h
@@ -0,0 +1,51 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.s
+
+============================================================================*/
+
+#ifndef QmitknnUNetWorker_h
+#define QmitknnUNetWorker_h
+
+#include "mitkProcessExecutor.h"
+#include <QMutex>
+#include <QObject>
+
+Q_DECLARE_METATYPE(mitk::ProcessExecutor::Pointer);
+Q_DECLARE_METATYPE(mitk::ProcessExecutor::ArgumentListType);
+
+/**
+ * @brief Class to execute some functions from the Segmentation Plugin in a seperate thread
+ */
+class nnUNetDownloadWorker : public QObject
+{
+  Q_OBJECT
+
+public slots:
+  /**
+   * @brief Starts the download process worker thread.
+   *
+   */
+  void DoWork(QString, QString, mitk::ProcessExecutor::Pointer, mitk::ProcessExecutor::ArgumentListType);
+
+signals:
+
+  /**
+   * @brief the signal emitted when a download process is finshed; success or failed
+   *
+   * @param exitCode
+   * @param message
+   */
+  void Exit(bool exitCode, const QString message);
+
+private:
+  QMutex mutex;
+};
+
+#endif
diff --git a/Modules/SegmentationUI/files.cmake b/Modules/SegmentationUI/files.cmake
index 17e542219b..818830625e 100644
--- a/Modules/SegmentationUI/files.cmake
+++ b/Modules/SegmentationUI/files.cmake
@@ -1,85 +1,77 @@
 set( CPP_FILES
-Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
-Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
-Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
+Qmitk/QmitkSegWithPreviewToolGUIBase.cpp
+Qmitk/QmitkMultiLabelSegWithPreviewToolGUIBase.cpp
 Qmitk/QmitkBinaryThresholdToolGUIBase.cpp
 Qmitk/QmitkBinaryThresholdToolGUI.cpp
 Qmitk/QmitkBinaryThresholdULToolGUI.cpp
 Qmitk/QmitkCalculateGrayValueStatisticsToolGUI.cpp
 Qmitk/QmitkConfirmSegmentationDialog.cpp
 Qmitk/QmitkCopyToClipBoardDialog.cpp
 Qmitk/QmitkDrawPaintbrushToolGUI.cpp
 Qmitk/QmitkErasePaintbrushToolGUI.cpp
 Qmitk/QmitkLiveWireTool2DGUI.cpp
-Qmitk/QmitkNewSegmentationDialog.cpp
 Qmitk/QmitkOtsuTool3DGUI.cpp
 Qmitk/QmitkPaintbrushToolGUI.cpp
 Qmitk/QmitkPickingToolGUI.cpp
 Qmitk/QmitkPixelManipulationToolGUI.cpp
 Qmitk/QmitkSlicesInterpolator.cpp
 Qmitk/QmitkToolGUI.cpp
 Qmitk/QmitkToolGUIArea.cpp
 Qmitk/QmitkToolSelectionBox.cpp
 Qmitk/QmitknnUNetToolGUI.cpp
-Qmitk/QmitknnUNetToolSlots.cpp
-#Added from ML
-Qmitk/QmitkLabelSetWidget.cpp
+Qmitk/QmitknnUNetWorker.cpp
 Qmitk/QmitkSurfaceStampWidget.cpp
 Qmitk/QmitkMaskStampWidget.cpp
 Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
+Qmitk/QmitkStaticDynamicSegmentationDialog.cpp
 Qmitk/QmitkSurfaceBasedInterpolatorWidget.cpp
 Qmitk/QmitkSimpleLabelSetListWidget.cpp
 )
 
 set(MOC_H_FILES
-Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h
-Qmitk/QmitkAutoSegmentationToolGUIBase.h
-Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
+Qmitk/QmitkSegWithPreviewToolGUIBase.h
+Qmitk/QmitkMultiLabelSegWithPreviewToolGUIBase.h
 Qmitk/QmitkBinaryThresholdToolGUIBase.h
 Qmitk/QmitkBinaryThresholdToolGUI.h
 Qmitk/QmitkBinaryThresholdULToolGUI.h
 Qmitk/QmitkCalculateGrayValueStatisticsToolGUI.h
 Qmitk/QmitkConfirmSegmentationDialog.h
 Qmitk/QmitkCopyToClipBoardDialog.h
 Qmitk/QmitkDrawPaintbrushToolGUI.h
 Qmitk/QmitkErasePaintbrushToolGUI.h
 Qmitk/QmitkLiveWireTool2DGUI.h
-Qmitk/QmitkNewSegmentationDialog.h
 Qmitk/QmitkOtsuTool3DGUI.h
 Qmitk/QmitkPaintbrushToolGUI.h
 Qmitk/QmitkPickingToolGUI.h
 Qmitk/QmitkPixelManipulationToolGUI.h
 Qmitk/QmitkSlicesInterpolator.h
 Qmitk/QmitkToolGUI.h
 Qmitk/QmitkToolGUIArea.h
 Qmitk/QmitkToolSelectionBox.h
 Qmitk/QmitknnUNetToolGUI.h
 Qmitk/QmitknnUNetGPU.h
+Qmitk/QmitknnUNetWorker.h
 Qmitk/QmitknnUNetEnsembleLayout.h
 Qmitk/QmitknnUNetFolderParser.h
-#Added from ML
-Qmitk/QmitkLabelSetWidget.h
 Qmitk/QmitkSurfaceStampWidget.h
 Qmitk/QmitkMaskStampWidget.h
 Qmitk/QmitkSliceBasedInterpolatorWidget.h
+Qmitk/QmitkStaticDynamicSegmentationDialog.h
 Qmitk/QmitkSurfaceBasedInterpolatorWidget.h
 Qmitk/QmitkSimpleLabelSetListWidget.h
 )
 
 set(UI_FILES
-Qmitk/QmitkAdaptiveRegionGrowingToolGUIControls.ui
 Qmitk/QmitkConfirmSegmentationDialog.ui
 Qmitk/QmitkOtsuToolWidgetControls.ui
 Qmitk/QmitkLiveWireTool2DGUIControls.ui
-#Added from ML
-Qmitk/QmitkLabelSetWidgetControls.ui
 Qmitk/QmitkSurfaceStampWidgetGUIControls.ui
 Qmitk/QmitkMaskStampWidgetGUIControls.ui
 Qmitk/QmitkSliceBasedInterpolatorWidgetGUIControls.ui
 Qmitk/QmitkSurfaceBasedInterpolatorWidgetGUIControls.ui
 Qmitk/QmitknnUNetToolGUIControls.ui
 )
 
 set(QRC_FILES
   resources/SegmentationUI.qrc
 )
diff --git a/Modules/SemanticRelations/Test/mitkSemanticRelationsTest.cpp b/Modules/SemanticRelations/Test/mitkSemanticRelationsTest.cpp
index 3759173fbe..70ff2f25e6 100644
--- a/Modules/SemanticRelations/Test/mitkSemanticRelationsTest.cpp
+++ b/Modules/SemanticRelations/Test/mitkSemanticRelationsTest.cpp
@@ -1,808 +1,947 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // mitk semantic relations
 #include "mitkSemanticRelationException.h"
 #include "mitkSemanticRelationsInference.h"
 #include "mitkSemanticRelationsIntegration.h"
 #include "mitkSemanticRelationsDataStorageAccess.h"
 #include "mitkRelationStorage.h"
 #include "mitkControlPointManager.h"
 #include "mitkDICOMHelper.h"
 #include "mitkLesionManager.h"
 #include "mitkSemanticRelationsTestHelper.h"
 #include "mitkUIDGeneratorBoost.h"
 
 // mitk core
 #include <mitkStandaloneDataStorage.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 #include <mitkPropertyNameHelper.h>
 
 // mitk persistence
 #include <mitkPersistenceService.h>
 
 class mitkSemanticRelationsTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkSemanticRelationsTestSuite);
   MITK_TEST(IntegrationTest);
   MITK_TEST(InferenceTest);
   MITK_TEST(DataStorageAccessTest);
   MITK_TEST(RemoveAndUnlinkTest);
+  MITK_TEST(LesionAndControlPointTest);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   mitk::DataStorage::Pointer m_DataStorage;
 
 public:
 
   void setUp() override
   {
     mitk::PersistenceService::LoadModule();
     m_DataStorage = mitk::StandaloneDataStorage::New();
   }
 
   void tearDown() override
   {
     // clear semantic relations storage
     mitk::SemanticRelationsTestHelper::ClearRelationStorage();
   }
 
   //////////////////////////////////////////////////////////////////////////
   // SPECIFIC TEST GROUPS
   //////////////////////////////////////////////////////////////////////////
   void IntegrationTest()
   {
     MITK_INFO << "=== IntegrationTest start ===";
     AddNewData();
     ExaminationPeriod();
     SegmentationAndLesion();
     InvalidData();
     MITK_INFO << "=== IntegrationTest end ===";
   }
 
   void InferenceTest()
   {
     MITK_INFO << "=== InferenceTest start ===";
     CombinedQueries();
     InstanceExistences();
     MITK_INFO << "=== InferenceTest end ===";
   }
 
   void DataStorageAccessTest()
   {
     MITK_INFO << "=== DataStorageAccessTest start ===";
     DataStorageAccess();
     MITK_INFO << "=== DataStorageAccessTest end ===";
   }
 
   void RemoveAndUnlinkTest()
   {
     MITK_INFO << "=== RemoveAndUnlinkTest start ===";
     CPRemoveAndUnlink();
     LesionRemoveAndUnlink();
     RemoveImagesAndSegmentation();
     MITK_INFO << "=== RemoveAndUnlinkTest end ===";
   }
 
+  void LesionAndControlPointTest()
+  {
+    MITK_INFO << "=== LesionAndControlPointTest start ===";
+    LesionDataTest();
+    LesionOverwriteTest();
+    MITK_INFO << "=== LesionAndControlPointTest end ===";
+  }
+
   //////////////////////////////////////////////////////////////////////////
   // SPECIFIC TESTS
   //////////////////////////////////////////////////////////////////////////
   // IntegrationTest
   void AddNewData()
   {
     MITK_INFO << "=== AddNewData";
 
     // load data
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
 
     auto image = mitk::SemanticRelationsTestHelper::GetPatientOneCTImage();
     m_DataStorage->Add(image);
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", image.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", image->GetData() != nullptr);
     semanticRelationsIntegration.AddImage(image);
 
     // start test
     auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
     CPPUNIT_ASSERT_MESSAGE("CaseID not correctly stored", allCaseIDs.front() == "Patient1");
     auto caseID = allCaseIDs.front();
 
     // test control point
     auto allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One control point should be stored", allControlPoints.size() == 1);
 
     auto controlPointOfImage = mitk::SemanticRelationsInference::GetControlPointOfImage(image);
     mitk::SemanticTypes::ControlPoint controlPointToCompare;
     controlPointToCompare.date = boost::gregorian::date(2019, 01, 01);
     CPPUNIT_ASSERT_MESSAGE("Control point not correctly stored", controlPointOfImage.date == controlPointToCompare.date);
 
     // test information type
     auto allInformationTypes = mitk::RelationStorage::GetAllInformationTypesOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One information type should be stored", allInformationTypes.size() == 1);
 
     auto informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(image);
     CPPUNIT_ASSERT_MESSAGE("Information type not correctly stored", informationType == "CT");
 
     semanticRelationsIntegration.SetInformationType(image, "MR");
     informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(image);
     CPPUNIT_ASSERT_MESSAGE("Information type not correctly stored", informationType == "MR");
   }
 
   void ExaminationPeriod()
   {
     MITK_INFO << "=== ExaminationPeriod";
 
     // load data
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
 
     auto MRImage = mitk::SemanticRelationsTestHelper::GetPatientOneMRImage();
     m_DataStorage->Add(MRImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", MRImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", MRImage->GetData() != nullptr);
     semanticRelationsIntegration.AddImage(MRImage);
 
     // start test
     auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
     CPPUNIT_ASSERT_MESSAGE("One CaseID should be stored", allCaseIDs.size() == 1);
     auto caseID = allCaseIDs.front();
 
     auto allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One control point should be stored", allControlPoints.size() == 1);
 
     auto controlPointOfImage = mitk::SemanticRelationsInference::GetControlPointOfImage(MRImage);
     mitk::SemanticTypes::ControlPoint controlPoint;
     controlPoint.date = boost::gregorian::date(2019, 01, 01);
     CPPUNIT_ASSERT_MESSAGE("Control point not correctly stored", controlPointOfImage.date == controlPoint.date);
 
-    auto examinationPeriod = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
-    CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", examinationPeriod.size() == 1);
+    auto allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", allExaminationPeriods.size() == 1);
 
     auto allImageIDs = mitk::RelationStorage::GetAllImageIDsOfControlPoint(caseID, controlPointOfImage);
     CPPUNIT_ASSERT_MESSAGE("Two images should reference the same control point", allImageIDs.size() == 2);
 
     // add additional control point to the same examination period
     // load data
     auto CTImage = mitk::SemanticRelationsTestHelper::GetPatientOneOtherCTImage();
     m_DataStorage->Add(CTImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", CTImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", CTImage->GetData() != nullptr);
     semanticRelationsIntegration.AddImage(CTImage);
 
     // start test
     allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
 
-    examinationPeriod = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
-    CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", examinationPeriod.size() == 1);
+    allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", allExaminationPeriods.size() == 1);
 
     // modify control point to create new examination period
     // current control point is 2019, 01, 31
     // new control point should exceed threshold (30 days) and create new examination period
     // new control point is 2019, 02, 01
     controlPoint.UID = mitk::UIDGeneratorBoost::GenerateUID();
     controlPoint.date = boost::gregorian::date(2019, 02, 01);
     semanticRelationsIntegration.UnlinkImageFromControlPoint(CTImage);
     semanticRelationsIntegration.SetControlPointOfImage(CTImage, controlPoint);
 
     allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
 
-    examinationPeriod = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
-    CPPUNIT_ASSERT_MESSAGE("Two examination periods should be stored", examinationPeriod.size() == 2);
+    allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Two examination periods should be stored", allExaminationPeriods.size() == 2);
+
+    auto examinationPeriod = allExaminationPeriods.front();
+    CPPUNIT_ASSERT_MESSAGE("Examination period name should be 'New examination period'", examinationPeriod.name == "New examination period");
+
+    examinationPeriod.name = "ExaminationPeriod_01";
+    semanticRelationsIntegration.RenameExaminationPeriod(caseID, examinationPeriod);
+
+    examinationPeriod = mitk::FindFittingExaminationPeriod(MRImage);
+    CPPUNIT_ASSERT_MESSAGE("Examination period name should be 'ExaminationPeriod_01'", examinationPeriod.name == "ExaminationPeriod_01");
+
+    examinationPeriod = mitk::FindFittingExaminationPeriod(CTImage);
+    CPPUNIT_ASSERT_MESSAGE("Examination period name should be 'New examination period'", examinationPeriod.name == "New examination period");
+
+    // modify control point to remove examination period and create new one before the first one
+    controlPoint.UID = mitk::UIDGeneratorBoost::GenerateUID();
+    controlPoint.date = boost::gregorian::date(2018, 01, 01);
+    semanticRelationsIntegration.UnlinkImageFromControlPoint(CTImage);
+    semanticRelationsIntegration.SetControlPointOfImage(CTImage, controlPoint);
+
+    allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("Examination period name should be 'ExaminationPeriod_01'", allExaminationPeriods.front().name == "ExaminationPeriod_01");
+    CPPUNIT_ASSERT_MESSAGE("Examination period name should be 'New examination period'", allExaminationPeriods.back().name == "New examination period");
+
+    mitk::SortAllExaminationPeriods(caseID, allExaminationPeriods);
+    CPPUNIT_ASSERT_MESSAGE("Examination period name should be 'New examination period'", allExaminationPeriods.front().name == "New examination period");
+    CPPUNIT_ASSERT_MESSAGE("Examination period name should be 'ExaminationPeriod_01'", allExaminationPeriods.back().name == "ExaminationPeriod_01");
+    CPPUNIT_ASSERT_MESSAGE("Two examination periods should be stored", allExaminationPeriods.size() == 2);
   }
 
   void SegmentationAndLesion()
   {
     MITK_INFO << "=== SegmentationAndLesion";
 
     // load data
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
 
     // Patient2
     auto image = mitk::SemanticRelationsTestHelper::GetPatientTwoPETImage();
     m_DataStorage->Add(image);
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", image.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", image->GetData() != nullptr);
     semanticRelationsIntegration.AddImage(image);
 
     auto segmentation = mitk::SemanticRelationsTestHelper::GetPatientTwoSegmentation();
     m_DataStorage->Add(segmentation, image);
     CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", segmentation.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", segmentation->GetData() != nullptr);
     semanticRelationsIntegration.AddSegmentation(segmentation, image);
 
     // start test
     auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
     CPPUNIT_ASSERT_MESSAGE("Two CaseIDs should be stored", allCaseIDs.size() == 2);
 
     // test lesion (add and link)
     auto lesion = mitk::GenerateNewLesion();
     semanticRelationsIntegration.AddLesionAndLinkSegmentation(segmentation, lesion);
 
     auto representedLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(segmentation);
     CPPUNIT_ASSERT_MESSAGE("Represented lesion should be the only stored lesion", lesion.UID == representedLesion.UID);
   }
 
   void InvalidData()
   {
     MITK_INFO << "=== InvalidData";
 
     // TEST INVALID CASE ID
     std::string caseID = "invalidID";
     auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No lesion should be stored, given a non-existing CaseID", allLesions.size() == 0);
 
     auto allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No control point should be stored, given a non-existing CaseID", allControlPoints.size() == 0);
 
     auto allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No examination periods should be stored, given a non-existing CaseID", allExaminationPeriods.size() == 0);
 
     auto allInformationTypes = mitk::RelationStorage::GetAllInformationTypesOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No information type should be stored, given a non-existing CaseID", allInformationTypes.size() == 0);
 
     auto allImageIDsOfCase = mitk::RelationStorage::GetAllImageIDsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No image ID should be stored, given a non-existing CaseID", allControlPoints.size() == 0);
 
+    bool instanceExists = mitk::RelationStorage::InstanceExists(caseID);
+    CPPUNIT_ASSERT_MESSAGE("CaseID should not exist", !instanceExists);
+
     // TEST INVALID DATE
     mitk::DataNode::Pointer invalidDateImage = mitk::SemanticRelationsTestHelper::GetInvalidDate();
     m_DataStorage->Add(invalidDateImage);
 
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", invalidDateImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", invalidDateImage->GetData() != nullptr);
 
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
     CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: AddImage",
       semanticRelationsIntegration.AddImage(invalidDateImage),
       mitk::SemanticRelationException);
 
     auto controlPointOfImage = mitk::SemanticRelationsInference::GetControlPointOfImage(invalidDateImage);
     CPPUNIT_ASSERT_MESSAGE("No control point should be stored for an invalid DICOM date", controlPointOfImage.UID.empty());
 
     // set invalid date format for current image
     // 0x0008, 0x0022 (AcquisitionDate), should be 20180101
     invalidDateImage->GetData()->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0022).c_str(),
       mitk::StringProperty::New("201811"));
     CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: GenerateControlPoint",
       mitk::GenerateControlPoint(invalidDateImage),
       mitk::SemanticRelationException);
 
     // set valid date format for current image and add image again (only control point should be updated)
     // 0x0008, 0x0022 (AcquisitionDate), should be 20180101
     invalidDateImage->GetData()->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0022).c_str(),
       mitk::StringProperty::New("20180101"));
     semanticRelationsIntegration.AddImage(invalidDateImage);
 
     controlPointOfImage = mitk::SemanticRelationsInference::GetControlPointOfImage(invalidDateImage);
     mitk::SemanticTypes::ControlPoint controlPointToCompare;
     controlPointToCompare.date = boost::gregorian::date(2018, 01, 01);
     CPPUNIT_ASSERT_MESSAGE("Control point not correctly stored", controlPointOfImage.date == controlPointToCompare.date);
 
     // TEST INVALID MODALITY
     mitk::DataNode::Pointer invalidModalityImage = mitk::SemanticRelationsTestHelper::GetInvalidModality();
     m_DataStorage->Add(invalidModalityImage);
 
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", invalidModalityImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", invalidModalityImage->GetData() != nullptr);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: AddImage",
       semanticRelationsIntegration.AddImage(invalidModalityImage),
       mitk::SemanticRelationException);
 
     auto informationTypeOfImage = mitk::SemanticRelationsInference::GetInformationTypeOfImage(invalidModalityImage);
     CPPUNIT_ASSERT_MESSAGE("No information type should be stored for an invalid DICOM date", informationTypeOfImage.empty());
 
     // set valid modality for current image and add image again
     // 0x0008, 0x0060 (Modality), should be CT
     invalidModalityImage->GetData()->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0060).c_str(),
       mitk::StringProperty::New("CT"));
     semanticRelationsIntegration.AddImage(invalidModalityImage);
 
     auto informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(invalidModalityImage);
     CPPUNIT_ASSERT_MESSAGE("Information type not correctly stored", informationType == "CT");
 
     // TEST INVALID ID
     mitk::DataNode::Pointer invalidIDImage = mitk::SemanticRelationsTestHelper::GetInvalidID();
     m_DataStorage->Add(invalidIDImage);
 
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", invalidModalityImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", invalidModalityImage->GetData() != nullptr);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: AddImage",
       semanticRelationsIntegration.AddImage(invalidIDImage),
       mitk::SemanticRelationException);
 
     // set valid ID for current image and add image again
     // 0x0020, 0x000e (SeriesInstanceUID)
     auto generatedUID = mitk::UIDGeneratorBoost::GenerateUID();
     invalidIDImage->GetData()->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0020, 0x000e).c_str(),
       mitk::StringProperty::New(generatedUID));
     semanticRelationsIntegration.AddImage(invalidIDImage);
 
     auto IDFromNode = mitk::GetIDFromDataNode(invalidIDImage);
     CPPUNIT_ASSERT_MESSAGE("ID not correctly stored", IDFromNode == generatedUID);
 
     // TEST INVALID CASE ID
     mitk::DataNode::Pointer invalidCaseIDImage = mitk::SemanticRelationsTestHelper::GetInvalidCaseID();
     m_DataStorage->Add(invalidCaseIDImage);
 
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", invalidModalityImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", invalidModalityImage->GetData() != nullptr);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: AddImage",
       semanticRelationsIntegration.AddImage(invalidCaseIDImage),
       mitk::SemanticRelationException);
 
     // set valid case ID for current image and add image again
     // 0x0010, 0x0010 (PatientName)
     invalidCaseIDImage->GetData()->SetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0010, 0x0010).c_str(),
       mitk::StringProperty::New("Patient7"));
     semanticRelationsIntegration.AddImage(invalidCaseIDImage);
 
     auto caseIDFromNode = mitk::GetCaseIDFromDataNode(invalidCaseIDImage);
     CPPUNIT_ASSERT_MESSAGE("Case ID not correctly stored", caseIDFromNode == "Patient7");
   }
 
   // InferenceTest
   void CombinedQueries()
   {
     MITK_INFO << "=== CombinedQueries";
 
     // add image with segmentation and lesion
     auto image = mitk::SemanticRelationsTestHelper::GetPatientTwoPETImage();
     m_DataStorage->Add(image);
 
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", image.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", image->GetData() != nullptr);
 
     auto segmentation = mitk::SemanticRelationsTestHelper::GetPatientTwoSegmentation();
     m_DataStorage->Add(segmentation, image);
 
     CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", segmentation.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", segmentation->GetData() != nullptr);
 
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
     semanticRelationsIntegration.AddImage(image);
     semanticRelationsIntegration.AddSegmentation(segmentation, image);
 
     auto caseID = mitk::GetCaseIDFromDataNode(image);
 
     auto lesion = mitk::GenerateNewLesion();
     semanticRelationsIntegration.AddLesionAndLinkSegmentation(segmentation, lesion);
 
     auto allLesionsOfImage = mitk::SemanticRelationsInference::GetAllLesionsOfImage(image);
     CPPUNIT_ASSERT_MESSAGE("One lesion should be stored", allLesionsOfImage.size() == 1);
 
     auto controlPoint = mitk::SemanticRelationsInference::GetControlPointOfImage(image);
     auto allLesionsOfControlPoint = mitk::SemanticRelationsInference::GetAllLesionsOfControlPoint(caseID, controlPoint);
     CPPUNIT_ASSERT_MESSAGE("Lesions should be the same", (allLesionsOfImage.size() == allLesionsOfControlPoint.size())
       && (allLesionsOfImage.front().UID == allLesionsOfControlPoint.front().UID));
 
     auto allImageIDsOfLesion = mitk::SemanticRelationsInference::GetAllImageIDsOfLesion(caseID, allLesionsOfControlPoint.front());
     CPPUNIT_ASSERT_MESSAGE("Image IDs should be the same", (allImageIDsOfLesion.size() == 1)
       && (allImageIDsOfLesion.front() == mitk::GetIDFromDataNode(image)));
 
     auto allControlPointsOfLesion = mitk::SemanticRelationsInference::GetAllControlPointsOfLesion(caseID, allLesionsOfImage.front());
     CPPUNIT_ASSERT_MESSAGE("Control points should be the same", (allControlPointsOfLesion.size() == 1)
       && (allControlPointsOfLesion.front().date == controlPoint.date));
 
     auto informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(image);
+    auto allLesionsOfInformationType = mitk::SemanticRelationsInference::GetAllLesionsOfInformationType(caseID, informationType);
+    CPPUNIT_ASSERT_MESSAGE("Lesions should be the same", (allLesionsOfImage.size() == allLesionsOfInformationType.size())
+      && (allLesionsOfImage.front().UID == allLesionsOfInformationType.front().UID));
+
     auto allControlPointsOfInformationType = mitk::SemanticRelationsInference::GetAllControlPointsOfInformationType(caseID, informationType);
     CPPUNIT_ASSERT_MESSAGE("Control points should be the same", (allControlPointsOfLesion.size() == 1)
       && (allControlPointsOfLesion.front().date == controlPoint.date));
 
     auto allInformationTypesOfControlPoint = mitk::SemanticRelationsInference::GetAllInformationTypesOfControlPoint(caseID, controlPoint);
     CPPUNIT_ASSERT_MESSAGE("Information types should be the same", (allInformationTypesOfControlPoint.size() == 1)
       && (allInformationTypesOfControlPoint.front() == informationType));
+
+    auto allSpecificLesions = mitk::SemanticRelationsInference::GetAllSpecificLesions(caseID, controlPoint, informationType);
+    CPPUNIT_ASSERT_MESSAGE("Lesions should be the same", (allLesionsOfImage.size() == allSpecificLesions.size())
+      && (allLesionsOfImage.front().UID == allSpecificLesions.front().UID));
   }
 
   void InstanceExistences()
   {
     MITK_INFO << "=== InstanceExistences";
 
     mitk::SemanticRelationsDataStorageAccess semanticRelationsDataStorageAccess(m_DataStorage);
     auto allSegmentationsOfCase = semanticRelationsDataStorageAccess.GetAllSegmentationsOfCase("Patient2");
     CPPUNIT_ASSERT_MESSAGE("One segmentation should be stored", allSegmentationsOfCase.size() == 1);
 
     auto segmentation = allSegmentationsOfCase.front();
     CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", segmentation.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", segmentation->GetData() != nullptr);
 
     bool valid = mitk::SemanticRelationsInference::IsRepresentingALesion(segmentation);
     CPPUNIT_ASSERT_MESSAGE("Segmentation node should represent a lesion", valid);
 
     auto caseID = "Patient2";
     valid = mitk::SemanticRelationsInference::IsRepresentingALesion(caseID, mitk::GetIDFromDataNode(segmentation));
     CPPUNIT_ASSERT_MESSAGE("Segmentation (via ID) should represent a lesion", valid);
 
     auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One lesion should be stored", allLesions.size() == 1);
 
     auto lesion = allLesions.front();
     valid = mitk::SemanticRelationsInference::IsLesionPresent(lesion, segmentation);
     CPPUNIT_ASSERT_MESSAGE("Lesion should be present on segmentation", valid);
 
     auto allImagesOfCase = semanticRelationsDataStorageAccess.GetAllImagesOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One image should be stored", allImagesOfCase.size() == 1);
 
     auto image = allImagesOfCase.front();
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", image.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", image->GetData() != nullptr);
 
     valid = mitk::SemanticRelationsInference::IsLesionPresent(lesion, image);
     CPPUNIT_ASSERT_MESSAGE("Lesion should be present on image", valid);
 
     valid = mitk::SemanticRelationsInference::IsLesionPresentOnImage(caseID, lesion, mitk::GetIDFromDataNode(image));
     CPPUNIT_ASSERT_MESSAGE("Lesion should be present on segmentation", valid);
 
     valid = mitk::SemanticRelationsInference::IsLesionPresentOnSegmentation(caseID, lesion, mitk::GetIDFromDataNode(segmentation));
     CPPUNIT_ASSERT_MESSAGE("Lesion should be present on image", valid);
 
     auto controlPoint = mitk::SemanticRelationsInference::GetControlPointOfImage(image);
     valid = mitk::SemanticRelationsInference::IsLesionPresentAtControlPoint(caseID, lesion, controlPoint);
     CPPUNIT_ASSERT_MESSAGE("Lesion should be present at control point", valid);
 
     controlPoint.date = boost::gregorian::date(2019, 01, 01);
     valid = mitk::SemanticRelationsInference::IsLesionPresentAtControlPoint(caseID, lesion, controlPoint);
     CPPUNIT_ASSERT_MESSAGE("No lesion should be present at control point", !valid);
 
     valid = mitk::SemanticRelationsInference::InstanceExists(image);
     CPPUNIT_ASSERT_MESSAGE("Image should exist", valid);
 
     valid = mitk::SemanticRelationsInference::InstanceExists(segmentation);
     CPPUNIT_ASSERT_MESSAGE("Segmentation should exist", valid);
 
     valid = mitk::SemanticRelationsInference::InstanceExists(caseID, lesion);
     CPPUNIT_ASSERT_MESSAGE("Lesion should exist", valid);
 
     auto emptyLesion = mitk::GenerateNewLesion("ExampleLesionClass");
     valid = mitk::SemanticRelationsInference::InstanceExists(caseID, emptyLesion);
     CPPUNIT_ASSERT_MESSAGE("Lesion should not exist", !valid);
 
     auto newControlPoint = mitk::SemanticTypes::ControlPoint();
     valid = mitk::SemanticRelationsInference::InstanceExists(caseID, newControlPoint);
     CPPUNIT_ASSERT_MESSAGE("Control point should not exist for this case", !valid);
 
     valid = mitk::SemanticRelationsInference::InstanceExists(caseID, controlPoint);
     CPPUNIT_ASSERT_MESSAGE("Control point should exist for this case", valid);
 
     auto allExaminationPeriod = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", allExaminationPeriod.size() == 1);
     auto examinationPeriod = allExaminationPeriod.front();
 
     valid = mitk::SemanticRelationsInference::InstanceExists(caseID, examinationPeriod);
     CPPUNIT_ASSERT_MESSAGE("Examination period should exist for this case", valid);
 
     auto informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(image);
     valid = mitk::SemanticRelationsInference::InstanceExists(caseID, informationType);
     CPPUNIT_ASSERT_MESSAGE("Control point should exist for this case", valid);
 
     valid = mitk::SemanticRelationsInference::InstanceExists(caseID, "CT");
     CPPUNIT_ASSERT_MESSAGE("Control point should not exist for this case", !valid);
 
     valid = mitk::SemanticRelationsInference::SpecificImageExists(caseID, lesion, informationType);
     CPPUNIT_ASSERT_MESSAGE("Specific image should exist for this case", valid);
 
     valid = mitk::SemanticRelationsInference::SpecificImageExists(caseID, lesion, controlPoint);
     CPPUNIT_ASSERT_MESSAGE("Specific image should exist for this case", valid);
 
     valid = mitk::SemanticRelationsInference::SpecificImageExists(caseID, informationType, controlPoint);
     CPPUNIT_ASSERT_MESSAGE("Specific image should exist for this case", valid);
   }
 
   // DataStorageAccessTest
   void DataStorageAccess()
   {
     MITK_INFO << "=== DataStorageAccess";
 
     // load data
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
 
     // Patient1
     auto CTImage = mitk::SemanticRelationsTestHelper::GetPatientOneCTImage();
     m_DataStorage->Add(CTImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", CTImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", CTImage->GetData() != nullptr);
     semanticRelationsIntegration.AddImage(CTImage);
 
     auto MRImage = mitk::SemanticRelationsTestHelper::GetPatientOneMRImage();
     m_DataStorage->Add(MRImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", MRImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", MRImage->GetData() != nullptr);
     semanticRelationsIntegration.AddImage(MRImage);
 
     auto otherCTImage = mitk::SemanticRelationsTestHelper::GetPatientOneOtherCTImage();
     m_DataStorage->Add(otherCTImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", otherCTImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", otherCTImage->GetData() != nullptr);
     semanticRelationsIntegration.AddImage(otherCTImage);
 
     // Patient2
     auto PETImage = mitk::SemanticRelationsTestHelper::GetPatientTwoPETImage();
     m_DataStorage->Add(PETImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", PETImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", PETImage->GetData() != nullptr);
     semanticRelationsIntegration.AddImage(PETImage);
 
     auto PETSegmentation = mitk::SemanticRelationsTestHelper::GetPatientTwoSegmentation();
     m_DataStorage->Add(PETSegmentation, PETImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", PETSegmentation.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", PETSegmentation->GetData() != nullptr);
     semanticRelationsIntegration.AddSegmentation(PETSegmentation, PETImage);
 
     auto lesion = mitk::GenerateNewLesion();
     semanticRelationsIntegration.AddLesionAndLinkSegmentation(PETSegmentation, lesion);
 
     // start test
     mitk::SemanticRelationsDataStorageAccess semanticRelationsDataStorageAccess(m_DataStorage);
 
     auto caseID = "Patient1";
     auto allSegmentationsOfCase = semanticRelationsDataStorageAccess.GetAllSegmentationsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No segmentation should be stored", allSegmentationsOfCase.size() == 0);
 
     auto allImagesOfCase = semanticRelationsDataStorageAccess.GetAllImagesOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Three images should be stored", allImagesOfCase.size() == 3);
 
     auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No lesion should be stored", allLesions.size() == 0);
 
     auto emptyLesion = mitk::GenerateNewLesion("ExampleLesionClass");
     CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: GetAllSegmentationsOfLesion",
       semanticRelationsDataStorageAccess.GetAllSegmentationsOfLesion(caseID, emptyLesion),
       mitk::SemanticRelationException);
 
+    auto examinationPeriod = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", examinationPeriod.size() == 1);
+    auto allSpecificImages = semanticRelationsDataStorageAccess.GetAllSpecificImages(caseID, "CT", examinationPeriod.front());
+    CPPUNIT_ASSERT_MESSAGE("Two CT images should be stored", allSpecificImages.size() == 2);
+
     caseID = "Patient2";
     allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One lesion should be stored", allLesions.size() == 1);
 
     lesion = allLesions.front();
     auto allSegmentationsOfLesion = semanticRelationsDataStorageAccess.GetAllSegmentationsOfLesion(caseID, lesion);
     CPPUNIT_ASSERT_MESSAGE("One segmentation should be stored", allSegmentationsOfLesion.size() == 1);
 
     auto allImagesOfLesion = semanticRelationsDataStorageAccess.GetAllImagesOfLesion(caseID, lesion);
     CPPUNIT_ASSERT_MESSAGE("One image should be stored", allImagesOfLesion.size() == 1);
 
     auto allControlPointsOfLesion = mitk::SemanticRelationsInference::GetAllControlPointsOfLesion(caseID, lesion);
     CPPUNIT_ASSERT_MESSAGE("One control point should be stored", allControlPointsOfLesion.size() == 1);
     auto controlPoint = allControlPointsOfLesion.front();
 
-    auto allSpecificImages = semanticRelationsDataStorageAccess.GetAllSpecificImages(caseID, controlPoint, "PT");
+    allSpecificImages = semanticRelationsDataStorageAccess.GetAllSpecificImages(caseID, controlPoint, "PT");
     CPPUNIT_ASSERT_MESSAGE("One image should be stored", allSpecificImages.size() == 1);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: GetAllSpecificImages",
       semanticRelationsDataStorageAccess.GetAllSpecificImages(caseID, controlPoint, "CT"),
       mitk::SemanticRelationException);
 
     auto allSpecificSegmentations = semanticRelationsDataStorageAccess.GetAllSpecificSegmentations(caseID, controlPoint, "PT");
     CPPUNIT_ASSERT_MESSAGE("One segmentation should be stored", allSpecificSegmentations.size() == 1);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: GetAllSpecificSegmentations",
       semanticRelationsDataStorageAccess.GetAllSpecificSegmentations(caseID, controlPoint, "MR"),
       mitk::SemanticRelationException);
+
+    auto specificSegmentation = semanticRelationsDataStorageAccess.GetSpecificSegmentation(caseID, controlPoint, "PT", lesion);
+    CPPUNIT_ASSERT_MESSAGE("One segmentation should be stored", specificSegmentation == PETSegmentation);
+
+    CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: GetAllSpecificSegmentations",
+      semanticRelationsDataStorageAccess.GetSpecificSegmentation(caseID, controlPoint, "CT", lesion),
+      mitk::SemanticRelationException);
   }
 
   // RemoveAndUnlinkTest
   void CPRemoveAndUnlink()
   {
     MITK_INFO << "=== RemoveAndUnlink";
 
     // load data
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
 
     auto CTImage = mitk::SemanticRelationsTestHelper::GetPatientThreeCTImage();
     m_DataStorage->Add(CTImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", CTImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", CTImage->GetData() != nullptr);
     semanticRelationsIntegration.AddImage(CTImage);
 
     auto MRImage = mitk::SemanticRelationsTestHelper::GetPatientThreeMRImage();
     m_DataStorage->Add(MRImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", MRImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", MRImage->GetData() != nullptr);
     semanticRelationsIntegration.AddImage(MRImage);
 
     // start test
     auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
     CPPUNIT_ASSERT_MESSAGE("One CaseID should be stored", allCaseIDs.size() == 1);
 
     auto caseID = allCaseIDs.front();
     CPPUNIT_ASSERT_MESSAGE("CaseID should be Patient3", caseID == "Patient3");
 
     auto allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One examination period should be sored", allExaminationPeriods.size() == 1);
 
     auto allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
 
     // control points
     auto CTControlPoint = mitk::SemanticRelationsInference::GetControlPointOfImage(CTImage);
     semanticRelationsIntegration.UnlinkImageFromControlPoint(CTImage);
 
     allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One examination period should be stored", allExaminationPeriods.size() == 1);
 
     allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One control point should be stored since one has been removed", allControlPoints.size() == 1);
 
     CTControlPoint = mitk::SemanticRelationsInference::GetControlPointOfImage(CTImage);
     CPPUNIT_ASSERT_MESSAGE("Control point should be removed", CTControlPoint.UID.empty());
 
     CTControlPoint = mitk::GenerateControlPoint(CTImage);
     semanticRelationsIntegration.SetControlPointOfImage(CTImage, CTControlPoint);
 
     allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One examination period should be sored", allExaminationPeriods.size() == 1);
 
     allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
 
     mitk::SemanticTypes::ControlPoint newCTControlPoint;
     newCTControlPoint.UID = mitk::UIDGeneratorBoost::GenerateUID();
     newCTControlPoint.date = boost::gregorian::date(2019, 03, 01);
     semanticRelationsIntegration.SetControlPointOfImage(CTImage, newCTControlPoint);
 
     allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One examination period should be sored", allExaminationPeriods.size() == 1);
 
     allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
 
     newCTControlPoint.UID = mitk::UIDGeneratorBoost::GenerateUID();
     newCTControlPoint.date = boost::gregorian::date(2019, 01, 01);
     semanticRelationsIntegration.SetControlPointOfImage(CTImage, newCTControlPoint);
 
     allExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two examination periods should be stored", allExaminationPeriods.size() == 2);
 
     allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two control points should be stored", allControlPoints.size() == 2);
   }
 
   void LesionRemoveAndUnlink()
   {
     MITK_INFO << "=== LesionRemoveAndUnlink";
 
     // load data
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
     mitk::SemanticRelationsDataStorageAccess semanticRelationsDataStorageAccess(m_DataStorage);
 
     auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
     CPPUNIT_ASSERT_MESSAGE("One CaseID should be stored", allCaseIDs.size() == 1);
     auto caseID = allCaseIDs.front();
 
     auto allImages = semanticRelationsDataStorageAccess.GetAllImagesOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two images should be stored", allImages.size() == 2);
 
     auto allCTImageIDs = mitk::RelationStorage::GetAllImageIDsOfInformationType(caseID, "CT");
     CPPUNIT_ASSERT_MESSAGE("One image should be stored", allCTImageIDs.size() == 1);
 
     auto allMRImageIDs = mitk::RelationStorage::GetAllImageIDsOfInformationType(caseID, "MR");
     CPPUNIT_ASSERT_MESSAGE("One image should be stored", allMRImageIDs.size() == 1);
 
     mitk::DataNode::Pointer CTImage;
     mitk::DataNode::Pointer MRImage;
     for (const auto& image : allImages)
     {
       auto imageID = mitk::GetIDFromDataNode(image);
       if (imageID == allCTImageIDs.front())
       {
         CTImage = image;
       }
       else if (imageID == allMRImageIDs.front())
       {
         MRImage = image;
       }
     }
 
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", CTImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", CTImage->GetData() != nullptr);
 
     CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", MRImage.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Image data is empty", MRImage->GetData() != nullptr);
 
     auto CTSegmentation = mitk::SemanticRelationsTestHelper::GetPatientThreeCTSegmentation();
     m_DataStorage->Add(CTSegmentation, CTImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", CTSegmentation.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", CTSegmentation->GetData() != nullptr);
     semanticRelationsIntegration.AddSegmentation(CTSegmentation, CTImage);
 
     auto MRSegmentation = mitk::SemanticRelationsTestHelper::GetPatientThreeMRSegmentation();
     m_DataStorage->Add(MRSegmentation, MRImage);
     CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", MRSegmentation.IsNotNull());
     CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", MRSegmentation->GetData() != nullptr);
     semanticRelationsIntegration.AddSegmentation(MRSegmentation, MRImage);
 
     auto newLesion = mitk::GenerateNewLesion();
     semanticRelationsIntegration.AddLesionAndLinkSegmentation(CTSegmentation, newLesion);
     newLesion = mitk::GenerateNewLesion();
     semanticRelationsIntegration.AddLesionAndLinkSegmentation(MRSegmentation, newLesion);
 
     // start test
     auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two lesions should be stored", allLesions.size() == 2);
 
     auto MRLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(MRSegmentation);
     semanticRelationsIntegration.UnlinkSegmentationFromLesion(MRSegmentation);
 
     allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two lesions should be stored", allLesions.size() == 2);
 
     auto emptyLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(MRSegmentation);
     CPPUNIT_ASSERT_MESSAGE("Lesion should be removed", emptyLesion.UID.empty());
 
     semanticRelationsIntegration.LinkSegmentationToLesion(MRSegmentation, MRLesion);
     allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two lesions should be stored", allLesions.size() == 2);
 
     auto CTLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(CTSegmentation);
     CPPUNIT_ASSERT_THROW_MESSAGE("Semantic relation exception not thrown: RemoveLesion",
       semanticRelationsIntegration.RemoveLesion(caseID, CTLesion),
       mitk::SemanticRelationException);
 
     semanticRelationsIntegration.UnlinkSegmentationFromLesion(CTSegmentation);
     semanticRelationsIntegration.RemoveLesion(caseID, CTLesion);
 
     allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One lesions should be stored since one has been removed", allLesions.size() == 1);
 
     CTLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(CTSegmentation);
     CPPUNIT_ASSERT_MESSAGE("Lesion should be removed", CTLesion.UID.empty());
   }
 
   void RemoveImagesAndSegmentation()
   {
     MITK_INFO << "=== RemoveImagesAndSegmentation";
 
     // load data
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
     mitk::SemanticRelationsDataStorageAccess semanticRelationsDataStorageAccess(m_DataStorage);
 
     auto allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
     CPPUNIT_ASSERT_MESSAGE("One CaseID should be stored", allCaseIDs.size() == 1);
     auto caseID = allCaseIDs.front();
 
     auto allImages = semanticRelationsDataStorageAccess.GetAllImagesOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two images should be stored", allImages.size() == 2);
 
     auto allSegmentations = semanticRelationsDataStorageAccess.GetAllSegmentationsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("Two segmentations should be stored", allSegmentations.size() == 2);
 
     for (const auto& image : allImages)
     {
       semanticRelationsIntegration.RemoveImage(image);
     }
 
     for (const auto& segmentation : allSegmentations)
     {
       semanticRelationsIntegration.RemoveSegmentation(segmentation);
     }
 
     allImages = semanticRelationsDataStorageAccess.GetAllImagesOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No images should be stored", allImages.size() == 0);
 
     allSegmentations = semanticRelationsDataStorageAccess.GetAllSegmentationsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No segmentations should be stored", allSegmentations.size() == 0);
 
     auto allControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No control point should be stored", allControlPoints.size() == 0);
 
     auto allInformationTypes = mitk::RelationStorage::GetAllInformationTypesOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("No information type should be stored", allInformationTypes.size() == 0);
 
     auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
     CPPUNIT_ASSERT_MESSAGE("One lesions should be stored", allLesions.size() == 1);
   }
 
+  // LesionAndControlPointTest
+  void LesionDataTest()
+  {
+    MITK_INFO << "=== LesionDataTest";
+
+    // load data
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+
+    // CT image
+    auto CTImage = mitk::SemanticRelationsTestHelper::GetPatientThreeCTImage();
+    m_DataStorage->Add(CTImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", CTImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", CTImage->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(CTImage);
+
+    // MR image
+    auto MRImage = mitk::SemanticRelationsTestHelper::GetPatientThreeMRImage();
+    m_DataStorage->Add(MRImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid image data node", MRImage.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Image data is empty", MRImage->GetData() != nullptr);
+    semanticRelationsIntegration.AddImage(MRImage);
+
+    auto segmentation = mitk::SemanticRelationsTestHelper::GetPatientThreeMRSegmentation();
+    m_DataStorage->Add(segmentation, MRImage);
+    CPPUNIT_ASSERT_MESSAGE("Not a valid segmentation data node", segmentation.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("Segmentation data is empty", segmentation->GetData() != nullptr);
+    semanticRelationsIntegration.AddSegmentation(segmentation, MRImage);
+
+    auto lesion = mitk::GenerateNewLesion();
+    semanticRelationsIntegration.AddLesionAndLinkSegmentation(segmentation, lesion);
+
+    auto caseID = "Patient3";
+    auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One lesions should be stored", allLesions.size() == 1);
+
+    lesion = allLesions.front();
+    mitk::LesionData lesionData(lesion);
+    mitk::ComputeLesionPresence(lesionData, caseID);
+
+    auto lesionByUID = mitk::GetLesionByUID(caseID, lesion.UID);
+    mitk::LesionData lesionByUIDData;
+    lesionByUIDData.SetLesion(lesionByUID);
+    mitk::ComputeLesionPresence(lesionByUIDData, caseID);
+
+    CPPUNIT_ASSERT_MESSAGE("Lesions should be equal", lesion.UID == lesionByUID.UID && lesionData.GetLesionUID() == lesionByUIDData.GetLesionUID());
+    CPPUNIT_ASSERT_MESSAGE("Lesion names should be equal", lesion.name == lesionByUID.name && lesionData.GetLesionName() == lesionByUIDData.GetLesionName());
+    CPPUNIT_ASSERT_MESSAGE("Lesion classes should be equal", lesion.lesionClass.UID == lesionByUID.lesionClass.UID);
+    CPPUNIT_ASSERT_MESSAGE("Lesion presences should be equal", lesionData.GetLesionPresence() == lesionByUIDData.GetLesionPresence());
+    CPPUNIT_ASSERT_MESSAGE("Lesion presence should be 'false' and 'true'", lesionData.GetLesionPresence()[0] == false && lesionData.GetLesionPresence()[1] == true);
+  }
+
+  void LesionOverwriteTest()
+  {
+    MITK_INFO << "=== LesionOverwriteTest";
+
+    auto caseID = "Patient3";
+    auto allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One lesions should be stored", allLesions.size() == 1);
+
+    auto lesion = allLesions.front();
+    CPPUNIT_ASSERT_MESSAGE("Lesion name should be 'New lesion'", lesion.name == "New lesion");
+    CPPUNIT_ASSERT_MESSAGE("Lesion class type should be empty", lesion.lesionClass.classType == "");
+
+    lesion.name = "Lesion_01";
+    lesion.lesionClass.classType = "Class_01";
+
+    mitk::SemanticRelationsIntegration semanticRelationsIntegration;
+    semanticRelationsIntegration.OverwriteLesion(caseID, lesion);
+
+    CPPUNIT_ASSERT_MESSAGE("Lesion name should be 'Lesion_01'", lesion.name == "Lesion_01");
+
+    auto foundLesionClass = mitk::FindExistingLesionClass(caseID, "Class_01");
+    CPPUNIT_ASSERT_MESSAGE("Lesion class type should be 'Class_01'", foundLesionClass.classType == "Class_01");
+
+    allLesions = mitk::RelationStorage::GetAllLesionsOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One lesions should be stored", allLesions.size() == 1);
+
+    auto allLesionClasses = mitk::SemanticRelationsInference::GetAllLesionClassesOfCase(caseID);
+    CPPUNIT_ASSERT_MESSAGE("One lesion class should be stored", allLesionClasses.size() == 1);
+  }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkSemanticRelations)
diff --git a/Modules/SemanticRelations/src/mitkSemanticRelationsDataStorageAccess.cpp b/Modules/SemanticRelations/src/mitkSemanticRelationsDataStorageAccess.cpp
index c2712ece4f..5994a9a4d7 100644
--- a/Modules/SemanticRelations/src/mitkSemanticRelationsDataStorageAccess.cpp
+++ b/Modules/SemanticRelations/src/mitkSemanticRelationsDataStorageAccess.cpp
@@ -1,338 +1,348 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkSemanticRelationsDataStorageAccess.h"
 
 // semantic relations module
 #include "mitkControlPointManager.h"
 #include "mitkDICOMHelper.h"
 #include "mitkNodePredicates.h"
 #include "mitkRelationStorage.h"
 #include "mitkSemanticRelationException.h"
 #include "mitkSemanticRelationsInference.h"
 
 // c++
 #include <iterator>
 #include <algorithm>
 
 mitk::SemanticRelationsDataStorageAccess::SemanticRelationsDataStorageAccess(DataStorage* dataStorage)
   : m_DataStorage(dataStorage)
 {
   // nothing here
 }
 
 /************************************************************************/
 /* functions to get instances / attributes                              */
 /************************************************************************/
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSegmentationsOfCase(const SemanticTypes::CaseID& caseID) const
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data storage.";
   }
 
   SemanticTypes::IDVector allSegmentationIDsOfCase = RelationStorage::GetAllSegmentationIDsOfCase(caseID);
   DataNodeVector allSegmentationsOfCase;
   // get all segmentation nodes of the current data storage
   // only those nodes are respected, that are currently held in the data storage
-  DataStorage::SetOfObjects::ConstPointer segmentationNodes = m_DataStorage.Lock()->GetSubset(NodePredicates::GetSegmentationPredicate());
+  DataStorage::SetOfObjects::ConstPointer segmentationNodes = dataStorage->GetSubset(NodePredicates::GetSegmentationPredicate());
   for (auto it = segmentationNodes->Begin(); it != segmentationNodes->End(); ++it)
   {
     DataNode* segmentationNode = it->Value();
 
     SemanticTypes::CaseID currentCaseID;
     SemanticTypes::ID segmentationID;
     try
     {
       // find the corresponding segmentation node for the given segmentation ID
       currentCaseID = GetCaseIDFromDataNode(segmentationNode);
       segmentationID = GetIDFromDataNode(segmentationNode);
     }
     catch (SemanticRelationException&)
     {
       // found a segmentation node that is not stored in the semantic relations
       // this segmentation node does not have any DICOM information --> exception thrown
       // continue with the next segmentation to compare IDs
       continue;
     }
 
     if (caseID == currentCaseID && (std::find(allSegmentationIDsOfCase.begin(), allSegmentationIDsOfCase.end(), segmentationID) != allSegmentationIDsOfCase.end()))
     {
       // found current image node in the storage, add it to the return vector
       allSegmentationsOfCase.push_back(segmentationNode);
     }
   }
 
   return allSegmentationsOfCase;
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSegmentationsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion) const
 {
   if (SemanticRelationsInference::InstanceExists(caseID, lesion))
   {
     // lesion exists, retrieve all case segmentations from the storage
     DataNodeVector allSegmentationsOfLesion = GetAllSegmentationsOfCase(caseID);
 
     // filter all segmentations: check for semantic relation with the given lesion using a lambda function
     auto lambda = [&lesion](DataNode::Pointer segmentation)
     {
       try
       {
         SemanticTypes::Lesion representedLesion = SemanticRelationsInference::GetLesionOfSegmentation(segmentation);
         return lesion.UID != representedLesion.UID;
       }
       catch (const SemanticRelationException&)
       {
         return true;
       }
     };
     allSegmentationsOfLesion.erase(std::remove_if(allSegmentationsOfLesion.begin(), allSegmentationsOfLesion.end(), lambda), allSegmentationsOfLesion.end());
 
     return allSegmentationsOfLesion;
   }
   else
   {
     mitkThrowException(SemanticRelationException) << "Could not find an existing lesion instance for the given caseID " << caseID << " and lesion " << lesion.UID << ".";
   }
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllImagesOfCase(const SemanticTypes::CaseID& caseID) const
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data storage.";
   }
 
   SemanticTypes::IDVector allImageIDsOfCase = RelationStorage::GetAllImageIDsOfCase(caseID);
   DataNodeVector allImagesOfCase;
   // get all image nodes of the current data storage
   // only those nodes are respected, that are currently held in the data storage
-  DataStorage::SetOfObjects::ConstPointer imageNodes = m_DataStorage.Lock()->GetSubset(NodePredicates::GetImagePredicate());
+  DataStorage::SetOfObjects::ConstPointer imageNodes = dataStorage->GetSubset(NodePredicates::GetImagePredicate());
   for (auto it = imageNodes->Begin(); it != imageNodes->End(); ++it)
   {
     DataNode* imageNode = it->Value();
 
     SemanticTypes::CaseID currentCaseID;
     SemanticTypes::ID imageID;
     try
     {
       // find the corresponding image node for the given segmentation ID
       currentCaseID = GetCaseIDFromDataNode(imageNode);
       imageID = GetIDFromDataNode(imageNode);
     }
     catch (SemanticRelationException&)
     {
       // found an image node that is not stored in the semantic relations
       // this image node does not have any DICOM information --> exception thrown
       // continue with the next image to compare IDs
       continue;
     }
 
     if (caseID == currentCaseID && (std::find(allImageIDsOfCase.begin(), allImageIDsOfCase.end(), imageID) != allImageIDsOfCase.end()))
     {
       // found current image node in the storage, add it to the return vector
       allImagesOfCase.push_back(imageNode);
     }
   }
 
   return allImagesOfCase;
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllImagesByID(const SemanticTypes::IDVector& imageIDs) const
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data storage.";
   }
 
   DataNodeVector allImagesOfCase;
   // get all image nodes of the current data storage
   // only those nodes are respected, that are currently held in the data storage
-  DataStorage::SetOfObjects::ConstPointer imageNodes = m_DataStorage.Lock()->GetSubset(NodePredicates::GetImagePredicate());
+  DataStorage::SetOfObjects::ConstPointer imageNodes = dataStorage->GetSubset(NodePredicates::GetImagePredicate());
   for (auto it = imageNodes->Begin(); it != imageNodes->End(); ++it)
   {
     DataNode* imageNode = it->Value();
 
     SemanticTypes::CaseID currentCaseID;
     SemanticTypes::ID imageID;
     try
     {
       // find the corresponding image node for the given segmentation ID
       imageID = GetIDFromDataNode(imageNode);
     }
     catch (SemanticRelationException&)
     {
       // found an image node that is not stored in the semantic relations
       // this image node does not have any DICOM information --> exception thrown
       // continue with the next image to compare IDs
       continue;
     }
 
     if (std::find(imageIDs.begin(), imageIDs.end(), imageID) != imageIDs.end())
     {
       // found current image node in the storage, add it to the return vector
       allImagesOfCase.push_back(imageNode);
     }
   }
 
   return allImagesOfCase;
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllImagesOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion) const
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data storage.";
   }
 
   DataNodeVector allImagesOfLesion;
   // 1. get all segmentations that define the lesion
   // 2. retrieve the parent node (source) of the found segmentation node
   DataNodeVector allSegmentationsOfLesion = GetAllSegmentationsOfLesion(caseID, lesion);
   for (const auto& segmentationNode : allSegmentationsOfLesion)
   {
     // get parent node of the current segmentation node with the node predicate
-    DataStorage::SetOfObjects::ConstPointer parentNodes = m_DataStorage.Lock()->GetSources(segmentationNode, NodePredicates::GetImagePredicate(), false);
+    DataStorage::SetOfObjects::ConstPointer parentNodes = dataStorage->GetSources(segmentationNode, NodePredicates::GetImagePredicate(), false);
     for (auto it = parentNodes->Begin(); it != parentNodes->End(); ++it)
     {
       DataNode::Pointer dataNode = it->Value();
       allImagesOfLesion.push_back(it->Value());
     }
   }
 
   std::sort(allImagesOfLesion.begin(), allImagesOfLesion.end());
   allImagesOfLesion.erase(std::unique(allImagesOfLesion.begin(), allImagesOfLesion.end()), allImagesOfLesion.end());
   return allImagesOfLesion;
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSpecificImages(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::InformationType& informationType) const
 {
   if (SemanticRelationsInference::InstanceExists(caseID, controlPoint))
   {
     if (SemanticRelationsInference::InstanceExists(caseID, informationType))
     {
       // control point exists, information type exists, retrieve all images from the storage
       DataNodeVector allImagesOfCase = GetAllImagesOfCase(caseID);
       // filter all images to remove the ones with a different control point and information type using a lambda function
       auto lambda = [&controlPoint, &informationType](DataNode::Pointer imageNode)
       {
         return (informationType != SemanticRelationsInference::GetInformationTypeOfImage(imageNode))
             || (controlPoint.date != SemanticRelationsInference::GetControlPointOfImage(imageNode).date);
       };
 
       allImagesOfCase.erase(std::remove_if(allImagesOfCase.begin(), allImagesOfCase.end(), lambda), allImagesOfCase.end());
 
       return allImagesOfCase;
     }
     else
     {
       mitkThrowException(SemanticRelationException) << "Could not find an existing information type for the given caseID " << caseID << " and information type " << informationType << ".";
     }
   }
   else
   {
     mitkThrowException(SemanticRelationException) << "Could not find an existing control point for the given caseID " << caseID << " and control point " << controlPoint.UID << ".";
   }
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSpecificImages(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType, const SemanticTypes::ExaminationPeriod& examinationPeriod) const
 {
   if (SemanticRelationsInference::InstanceExists(caseID, informationType))
   {
     if (SemanticRelationsInference::InstanceExists(caseID, examinationPeriod))
     {
       // examination period exists, information type exists, retrieve all imageIDs from the storage
       auto allImageIDsOfExaminationPeriod = SemanticRelationsInference::GetAllImageIDsOfExaminationPeriod(caseID, examinationPeriod);
       // filter all images to remove the ones with a different information type using a lambda function
       auto lambda = [&caseID, &informationType](SemanticTypes::ID imageID)
       {
         return (informationType != RelationStorage::GetInformationTypeOfImage(caseID, imageID));
       };
 
       allImageIDsOfExaminationPeriod.erase(std::remove_if(allImageIDsOfExaminationPeriod.begin(), allImageIDsOfExaminationPeriod.end(), lambda), allImageIDsOfExaminationPeriod.end());
 
       auto allImagesOfExaminationPeriod = GetAllImagesByID(allImageIDsOfExaminationPeriod);
       return allImagesOfExaminationPeriod;
     }
     else
     {
       mitkThrowException(SemanticRelationException) << "Could not find an existing examination period for the given caseID " << caseID << " and examination period " << examinationPeriod.name << ".";
     }
   }
   else
   {
     mitkThrowException(SemanticRelationException) << "Could not find an existing information type for the given caseID " << caseID << " and information type " << informationType << ".";
   }
 }
 
 mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSpecificSegmentations(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::InformationType& informationType) const
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     mitkThrow() << "Not a valid data storage.";
   }
 
   DataNodeVector allSpecificImages;
   try
   {
     allSpecificImages = GetAllSpecificImages(caseID, controlPoint, informationType);
 
   }
   catch (SemanticRelationException& e)
   {
     mitkReThrow(e) << "Cannot get the specific segmentation.";
   }
 
   DataNodeVector allSpecificSegmentations;
   for (const auto& imageNode : allSpecificImages)
   {
-    DataStorage::SetOfObjects::ConstPointer segmentationNodes = m_DataStorage.Lock()->GetDerivations(imageNode, NodePredicates::GetSegmentationPredicate(), false);
+    DataStorage::SetOfObjects::ConstPointer segmentationNodes = dataStorage->GetDerivations(imageNode, NodePredicates::GetSegmentationPredicate(), false);
     for (auto it = segmentationNodes->Begin(); it != segmentationNodes->End(); ++it)
     {
       allSpecificSegmentations.push_back(it->Value());
     }
   }
 
   return allSpecificSegmentations;
 }
 
 mitk::DataNode::Pointer mitk::SemanticRelationsDataStorageAccess::GetSpecificSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint,
   const SemanticTypes::InformationType& informationType, const SemanticTypes::Lesion& lesion) const
 {
   if (m_DataStorage.IsExpired())
   {
     mitkThrow() << "Not a valid data storage.";
   }
 
   DataNodeVector allSpecificSegmentations;
   try
   {
     allSpecificSegmentations = GetAllSpecificSegmentations(caseID, controlPoint, informationType);
 
   }
   catch (SemanticRelationException& e)
   {
       mitkReThrow(e) << "Cannot get the specific segmentation.";
   }
 
   for (const auto& segmentationNode : allSpecificSegmentations)
   {
     SemanticTypes::Lesion representedLesion = SemanticRelationsInference::GetLesionOfSegmentation(segmentationNode);
     if (representedLesion.UID == lesion.UID)
     {
       return segmentationNode;
     }
   }
 
   return mitk::DataNode::Pointer();
 }
diff --git a/Modules/SemanticRelations/src/mitkSemanticRelationsInference.cpp b/Modules/SemanticRelations/src/mitkSemanticRelationsInference.cpp
index ac1cc937a8..af3bdfadb3 100644
--- a/Modules/SemanticRelations/src/mitkSemanticRelationsInference.cpp
+++ b/Modules/SemanticRelations/src/mitkSemanticRelationsInference.cpp
@@ -1,587 +1,582 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkSemanticRelationsInference.h"
 
 // semantic relations module
 #include "mitkControlPointManager.h"
 #include "mitkDICOMHelper.h"
 #include "mitkNodePredicates.h"
 #include "mitkRelationStorage.h"
 #include "mitkSemanticRelationException.h"
 
 /************************************************************************/
 /* functions to get instances / attributes                              */
 /************************************************************************/
 
 mitk::SemanticTypes::LesionClassVector mitk::SemanticRelationsInference::GetAllLesionClassesOfCase(const SemanticTypes::CaseID& caseID)
 {
   SemanticTypes::LesionVector allLesionsOfCase = RelationStorage::GetAllLesionsOfCase(caseID);
   SemanticTypes::LesionClassVector allLesionClassesOfCase;
 
   for (const auto& lesion : allLesionsOfCase)
   {
     allLesionClassesOfCase.push_back(lesion.lesionClass);
   }
 
   // remove duplicate entries
   auto lessThan = [](const SemanticTypes::LesionClass& lesionClassLeft, const SemanticTypes::LesionClass& lesionClassRight)
   {
     return lesionClassLeft.UID < lesionClassRight.UID;
   };
 
   auto equal = [](const SemanticTypes::LesionClass& lesionClassLeft, const SemanticTypes::LesionClass& lesionClassRight)
   {
     return lesionClassLeft.UID == lesionClassRight.UID;
   };
 
   std::sort(allLesionClassesOfCase.begin(), allLesionClassesOfCase.end(), lessThan);
   allLesionClassesOfCase.erase(std::unique(allLesionClassesOfCase.begin(), allLesionClassesOfCase.end(), equal), allLesionClassesOfCase.end());
 
   return allLesionClassesOfCase;
 }
 
 mitk::SemanticTypes::Lesion mitk::SemanticRelationsInference::GetLesionOfSegmentation(const DataNode* segmentationNode)
 {
   if (nullptr == segmentationNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid segmentation data node.";
   }
 
   SemanticTypes::CaseID caseID = "";
   SemanticTypes::ID segmentationID = "";
   try
   {
     caseID = GetCaseIDFromDataNode(segmentationNode);
     segmentationID = GetIDFromDataNode(segmentationNode);
   }
   catch (SemanticRelationException& e)
   {
     mitkReThrow(e) << "Cannot get the lesion of the given segmentation data node.";
   }
 
   return RelationStorage::GetLesionOfSegmentation(caseID, segmentationID);
 }
 
 mitk::SemanticTypes::LesionVector mitk::SemanticRelationsInference::GetAllLesionsOfImage(const DataNode* imageNode)
 {
   if (nullptr == imageNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
   }
 
   SemanticTypes::CaseID caseID = "";
   SemanticTypes::ID imageID = "";
   try
   {
     caseID = GetCaseIDFromDataNode(imageNode);
     imageID = GetIDFromDataNode(imageNode);
   }
   catch (SemanticRelationException& e)
   {
     mitkReThrow(e) << "Cannot get all lesions of the given image data node.";
   }
 
   SemanticTypes::LesionVector allLesionsOfImage;
   // 1. get all segmentations that are connected to the given image
   // 2. get the lesion of each segmentation
   // 3. guarantee uniqueness of lesions
   SemanticTypes::IDVector allSegmentationIDsOfImage = RelationStorage::GetAllSegmentationIDsOfImage(caseID, imageID);
   for (const auto& segmentationID : allSegmentationIDsOfImage)
   {
     // get represented lesion of the current segmentation
     SemanticTypes::Lesion representedLesion = RelationStorage::GetLesionOfSegmentation(caseID, segmentationID);
     if (!representedLesion.UID.empty())
     {
       allLesionsOfImage.push_back(representedLesion);
     }
   }
 
   // remove duplicate entries
   auto lessThan = [](const SemanticTypes::Lesion& lesionLeft, const SemanticTypes::Lesion& lesionRight)
   {
     return lesionLeft.UID < lesionRight.UID;
   };
 
   auto equal = [](const SemanticTypes::Lesion& lesionLeft, const SemanticTypes::Lesion& lesionRight)
   {
     return lesionLeft.UID == lesionRight.UID;
   };
 
   std::sort(allLesionsOfImage.begin(), allLesionsOfImage.end(), lessThan);
   allLesionsOfImage.erase(std::unique(allLesionsOfImage.begin(), allLesionsOfImage.end(), equal), allLesionsOfImage.end());
 
   return allLesionsOfImage;
 }
 
 mitk::SemanticTypes::LesionVector mitk::SemanticRelationsInference::GetAllLesionsOfControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::LesionVector allLesions = RelationStorage::GetAllLesionsOfCase(caseID);
 
   // filter the lesions: use only those, where the associated data is connected to image data that refers to the given control point using a lambda function
   auto lambda = [&caseID, &controlPoint](const SemanticTypes::Lesion& lesion)
   {
     return !SpecificImageExists(caseID, lesion, controlPoint);
   };
 
   allLesions.erase(std::remove_if(allLesions.begin(), allLesions.end(), lambda), allLesions.end());
 
   return allLesions;
 }
 
 mitk::SemanticTypes::LesionVector mitk::SemanticRelationsInference::GetAllLesionsOfInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType)
 {
   SemanticTypes::LesionVector allLesions = RelationStorage::GetAllLesionsOfCase(caseID);
 
   // filter the lesions: use only those, where the associated data is connected to image data that refers to the given information type using a lambda function
   auto lambda = [&caseID, &informationType](const SemanticTypes::Lesion& lesion)
   {
     return !SpecificImageExists(caseID, lesion, informationType);
   };
 
   allLesions.erase(std::remove_if(allLesions.begin(), allLesions.end(), lambda), allLesions.end());
 
   return allLesions;
 }
 
 mitk::SemanticTypes::LesionVector mitk::SemanticRelationsInference::GetAllSpecificLesions(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::InformationType& informationType)
 {
   auto allLesionsOfControlPoint = GetAllLesionsOfControlPoint(caseID, controlPoint);
   auto allLesionsOfInformationType = GetAllLesionsOfInformationType(caseID, informationType);
   SemanticTypes::LesionVector allLesionsIntersection;
 
   auto lessThan = [](const SemanticTypes::Lesion& lesionLeft, const SemanticTypes::Lesion& lesionRight)
   {
     return lesionLeft.UID < lesionRight.UID;
   };
 
-  auto equal = [](const SemanticTypes::Lesion& lesionLeft, const SemanticTypes::Lesion& lesionRight)
-  {
-    return lesionLeft.UID == lesionRight.UID;
-  };
-
   std::sort(allLesionsOfControlPoint.begin(), allLesionsOfControlPoint.end(), lessThan);
   std::sort(allLesionsOfInformationType.begin(), allLesionsOfInformationType.end(), lessThan);
   SemanticTypes::IDVector allImageIDsIntersection;
   // set_intersection removes duplicated nodes
   std::set_intersection(allLesionsOfControlPoint.begin(), allLesionsOfControlPoint.end(),
     allLesionsOfInformationType.begin(), allLesionsOfInformationType.end(),
-    std::back_inserter(allLesionsIntersection), equal);
+    std::back_inserter(allLesionsIntersection), lessThan);
 
   return allLesionsIntersection;
 }
 
 bool mitk::SemanticRelationsInference::IsRepresentingALesion(const DataNode* segmentationNode)
 {
   SemanticTypes::Lesion representedLesion;
   try
   {
     representedLesion = GetLesionOfSegmentation(segmentationNode);
   }
   catch (const SemanticRelationException&)
   {
     return false;
   }
 
   return !representedLesion.UID.empty();
 }
 
 bool mitk::SemanticRelationsInference::IsRepresentingALesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::ID& segmentationID)
 {
   SemanticTypes::Lesion representedLesion = RelationStorage::GetLesionOfSegmentation(caseID, segmentationID);
   return !representedLesion.UID.empty();
 }
 
 bool mitk::SemanticRelationsInference::IsLesionPresent(const SemanticTypes::Lesion& lesion, const DataNode* dataNode)
 {
   SemanticTypes::CaseID caseID = "";
   SemanticTypes::ID dataNodeID = "";
   try
   {
     caseID = GetCaseIDFromDataNode(dataNode);
     dataNodeID = GetIDFromDataNode(dataNode);
   }
   catch (const SemanticRelationException&)
   {
     return false;
   }
 
   if (NodePredicates::GetImagePredicate()->CheckNode(dataNode))
   {
     return IsLesionPresentOnImage(caseID, lesion, dataNodeID);
   }
 
   if (NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
   {
     return IsLesionPresentOnSegmentation(caseID, lesion, dataNodeID);
   }
 
   return false;
 }
 
 bool mitk::SemanticRelationsInference::IsLesionPresentOnImage(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ID& imageID)
 {
   SemanticTypes::IDVector allImageIDsOfLesion;
   try
   {
     allImageIDsOfLesion = GetAllImageIDsOfLesion(caseID, lesion);
   }
   catch (SemanticRelationException& e)
   {
     mitkReThrow(e) << "Cannot get all image IDs of the given lesion to determine the lesion presence.";
   }
 
   for (const auto& imageIDOfLesion : allImageIDsOfLesion)
   {
     if (imageIDOfLesion == imageID)
     {
       return true;
     }
   }
 
   return false;
 }
 
 bool mitk::SemanticRelationsInference::IsLesionPresentOnSegmentation(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ID& segmentationID)
 {
   const auto representedLesion = RelationStorage::GetLesionOfSegmentation(caseID, segmentationID);
   return lesion.UID == representedLesion.UID;
 }
 
 bool mitk::SemanticRelationsInference::IsLesionPresentAtControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::IDVector allImageIDsOfLesion;
   try
   {
     allImageIDsOfLesion = GetAllImageIDsOfLesion(caseID, lesion);
   }
   catch (SemanticRelationException& e)
   {
     mitkReThrow(e) << "Cannot get all image IDs of the given lesion to determine the lesion presence.";
   }
 
   for (const auto& imageIDOfLesion : allImageIDsOfLesion)
   {
     auto imageControlPoint = RelationStorage::GetControlPointOfImage(caseID, imageIDOfLesion);
     if (imageControlPoint.date == controlPoint.date)
     {
       return true;
     }
   }
 
   return false;
 }
 
 bool mitk::SemanticRelationsInference::InstanceExists(const DataNode* dataNode)
 {
   SemanticTypes::CaseID caseID = "";
   SemanticTypes::ID dataNodeID = "";
   try
   {
     caseID = GetCaseIDFromDataNode(dataNode);
     dataNodeID = GetIDFromDataNode(dataNode);
   }
   catch (const SemanticRelationException&)
   {
     return false;
   }
 
   if (NodePredicates::GetImagePredicate()->CheckNode(dataNode))
   {
     SemanticTypes::IDVector allImageIDsOfCase = RelationStorage::GetAllImageIDsOfCase(caseID);
     return std::find(allImageIDsOfCase.begin(), allImageIDsOfCase.end(), dataNodeID) != allImageIDsOfCase.end();
   }
 
   if (NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
   {
     SemanticTypes::IDVector allSegmentationIDsOfCase = RelationStorage::GetAllSegmentationIDsOfCase(caseID);
     return std::find(allSegmentationIDsOfCase.begin(), allSegmentationIDsOfCase.end(), dataNodeID) != allSegmentationIDsOfCase.end();
   }
 
   return false;
 }
 
 bool mitk::SemanticRelationsInference::InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   SemanticTypes::LesionVector allLesions = RelationStorage::GetAllLesionsOfCase(caseID);
 
   // filter all lesions: check for equality with the given lesion using a lambda function
   auto lambda = [&lesion](const SemanticTypes::Lesion& currentLesion)
   {
     return currentLesion.UID == lesion.UID;
   };
 
   const auto existingLesion = std::find_if(allLesions.begin(), allLesions.end(), lambda);
 
   return existingLesion != allLesions.end();
 }
 
 mitk::SemanticTypes::IDVector mitk::SemanticRelationsInference::GetAllImageIDsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   if (!InstanceExists(caseID, lesion))
   {
     mitkThrowException(SemanticRelationException) << "Could not find an existing lesion instance for the given caseID " << caseID << " and lesion " << lesion.UID << ".";
   }
 
   SemanticTypes::IDVector allImageIDsOfLesion;
   // 1. get all segmentations that define the lesion
   // 2. get the parentID (imageID) of each segmentation
   // 3. guarantee uniqueness of image IDs
   SemanticTypes::IDVector allSegmentationIDsOfLesion = RelationStorage::GetAllSegmentationIDsOfLesion(caseID, lesion);
   for (const auto& segmentationID : allSegmentationIDsOfLesion)
   {
     // get parent ID of the current segmentation ID
     SemanticTypes::ID imageID = RelationStorage::GetImageIDOfSegmentation(caseID, segmentationID);
     if(!imageID.empty())
     {
       allImageIDsOfLesion.push_back(imageID);
     }
   }
 
   std::sort(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end());
   allImageIDsOfLesion.erase(std::unique(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end()), allImageIDsOfLesion.end());
 
   return allImageIDsOfLesion;
 }
 
 mitk::SemanticTypes::IDVector mitk::SemanticRelationsInference::GetAllImageIDsOfExaminationPeriod(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod)
 {
   if (!InstanceExists(caseID, examinationPeriod))
   {
     mitkThrowException(SemanticRelationException) << "Could not find an existing examination period for the given caseID " << caseID << " and examination period " << examinationPeriod.name << ".";
   }
 
   SemanticTypes::IDVector allImageIDsOfExaminationPeriod;
   // 1. get all control point UIDs of the examination period
   // 2. get all images of each control points to find all images of the examination period
   SemanticTypes::ControlPoint controlPoint;
   for (const auto& controlPointUID : examinationPeriod.controlPointUIDs)
   {
     controlPoint = GetControlPointByUID(caseID, controlPointUID);
     auto allImageIDsOfControlPoint = RelationStorage::GetAllImageIDsOfControlPoint(caseID, controlPoint);
     allImageIDsOfExaminationPeriod.insert(allImageIDsOfExaminationPeriod.end(), allImageIDsOfControlPoint.begin(), allImageIDsOfControlPoint.end());
   }
 
   return allImageIDsOfExaminationPeriod;
 }
 
 mitk::SemanticTypes::ControlPoint mitk::SemanticRelationsInference::GetControlPointOfImage(const DataNode* imageNode)
 {
   if (nullptr == imageNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid data node.";
   }
 
   SemanticTypes::CaseID caseID = "";
   SemanticTypes::ID imageID = "";
   try
   {
     caseID = GetCaseIDFromDataNode(imageNode);
     imageID = GetIDFromDataNode(imageNode);
   }
   catch (SemanticRelationException& e)
   {
     mitkReThrow(e) << "Cannot get the control point of the given image data node.";
   }
 
   return RelationStorage::GetControlPointOfImage(caseID, imageID);
 }
 
 mitk::SemanticTypes::ControlPointVector mitk::SemanticRelationsInference::GetAllControlPointsOfLesion(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion)
 {
   SemanticTypes::ControlPointVector allControlPoints = RelationStorage::GetAllControlPointsOfCase(caseID);
 
   // filter the control points: use only those, where the associated image data has a segmentation that refers to the given lesion using a lambda function
   auto lambda = [&caseID, &lesion](const SemanticTypes::ControlPoint& controlPoint)
   {
     return !SpecificImageExists(caseID, lesion, controlPoint);
   };
 
   allControlPoints.erase(std::remove_if(allControlPoints.begin(), allControlPoints.end(), lambda), allControlPoints.end());
 
   return allControlPoints;
 }
 
 mitk::SemanticTypes::ControlPointVector mitk::SemanticRelationsInference::GetAllControlPointsOfInformationType(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType)
 {
   SemanticTypes::ControlPointVector allControlPoints = RelationStorage::GetAllControlPointsOfCase(caseID);
 
   // filter the control points: use only those, where the associated image data refers to the given information type using a lambda function
   auto lambda = [&caseID, &informationType](const SemanticTypes::ControlPoint& controlPoint)
   {
     return !SpecificImageExists(caseID, informationType, controlPoint);
   };
 
   allControlPoints.erase(std::remove_if(allControlPoints.begin(), allControlPoints.end(), lambda), allControlPoints.end());
 
   return allControlPoints;
 }
 
 bool mitk::SemanticRelationsInference::InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::ControlPointVector allControlPoints = RelationStorage::GetAllControlPointsOfCase(caseID);
 
   // filter all control points: check for equality with the given control point using a lambda function
   auto lambda = [&controlPoint](const SemanticTypes::ControlPoint& currentControlPoint) { return currentControlPoint.UID == controlPoint.UID; };
   const auto existingControlPoint = std::find_if(allControlPoints.begin(), allControlPoints.end(), lambda);
 
   if (existingControlPoint != allControlPoints.end())
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
 bool mitk::SemanticRelationsInference::InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::ExaminationPeriod& examinationPeriod)
 {
   SemanticTypes::ExaminationPeriodVector allExaminationPeriods = RelationStorage::GetAllExaminationPeriodsOfCase(caseID);
 
   // filter all examination periods: check for equality with the given examination period using a lambda function
   auto lambda = [&examinationPeriod](const SemanticTypes::ExaminationPeriod& currentExaminationPeriod) { return currentExaminationPeriod.UID == examinationPeriod.UID; };
   const auto existingExaminationPeriod = std::find_if(allExaminationPeriods.begin(), allExaminationPeriods.end(), lambda);
 
   if (existingExaminationPeriod != allExaminationPeriods.end())
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
 mitk::SemanticTypes::InformationType mitk::SemanticRelationsInference::GetInformationTypeOfImage(const DataNode* imageNode)
 {
   if (nullptr == imageNode)
   {
     mitkThrowException(SemanticRelationException) << "Not a valid image data node.";
   }
 
   SemanticTypes::CaseID caseID = "";
   SemanticTypes::ID imageID = "";
   try
   {
     caseID = GetCaseIDFromDataNode(imageNode);
     imageID = GetIDFromDataNode(imageNode);
   }
   catch (SemanticRelationException& e)
   {
     mitkReThrow(e) << "Cannot get the information type of the given image data node.";
   }
 
   return RelationStorage::GetInformationTypeOfImage(caseID, imageID);
 }
 
 mitk::SemanticTypes::InformationTypeVector mitk::SemanticRelationsInference::GetAllInformationTypesOfControlPoint(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::InformationTypeVector allInformationTypes = RelationStorage::GetAllInformationTypesOfCase(caseID);
 
   // filter the information types: use only those, where the associated data refers to the given control point using a lambda function
   auto lambda = [&caseID, &controlPoint](const SemanticTypes::InformationType& informationType)
   {
     return !SpecificImageExists(caseID, informationType, controlPoint);
   };
 
   allInformationTypes.erase(std::remove_if(allInformationTypes.begin(), allInformationTypes.end(), lambda), allInformationTypes.end());
 
   return allInformationTypes;
 }
 
 bool mitk::SemanticRelationsInference::InstanceExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType)
 {
   SemanticTypes::InformationTypeVector allInformationTypes = RelationStorage::GetAllInformationTypesOfCase(caseID);
 
   // filter all information types: check for equality with the given information type using a lambda function
   auto lambda = [&informationType](const SemanticTypes::InformationType& currentInformationType) { return currentInformationType == informationType; };
   const auto existingInformationType = std::find_if(allInformationTypes.begin(), allInformationTypes.end(), lambda);
 
   if (existingInformationType != allInformationTypes.end())
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
 bool mitk::SemanticRelationsInference::SpecificImageExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::InformationType& informationType)
 {
   SemanticTypes::IDVector allImageIDsOfLesion;
   try
   {
     allImageIDsOfLesion = GetAllImageIDsOfLesion(caseID, lesion);
   }
   catch (const SemanticRelationException&)
   {
     return false;
   }
 
   SemanticTypes::IDVector allImageIDsOfInformationType = RelationStorage::GetAllImageIDsOfInformationType(caseID, informationType);
 
   std::sort(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end());
   std::sort(allImageIDsOfInformationType.begin(), allImageIDsOfInformationType.end());
   SemanticTypes::IDVector allImageIDsIntersection;
   // set_intersection removes duplicated nodes, since 'GetAllImageIDsOfInformationType' only contains at most one of each node
   std::set_intersection(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end(),
     allImageIDsOfInformationType.begin(), allImageIDsOfInformationType.end(),
     std::back_inserter(allImageIDsIntersection));
 
   // if the vector of intersecting image IDs is empty, the information type does not contain the lesion
   return !allImageIDsIntersection.empty();
 }
 
 bool mitk::SemanticRelationsInference::SpecificImageExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::Lesion& lesion, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::IDVector allImageIDsOfLesion;
   try
   {
     allImageIDsOfLesion = GetAllImageIDsOfLesion(caseID, lesion);
   }
   catch (const SemanticRelationException&)
   {
     return false;
   }
 
   SemanticTypes::IDVector allImageIDsOfControlPoint = RelationStorage::GetAllImageIDsOfControlPoint(caseID, controlPoint);
 
   std::sort(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end());
   std::sort(allImageIDsOfControlPoint.begin(), allImageIDsOfControlPoint.end());
   SemanticTypes::IDVector allImageIDsIntersection;
   // set_intersection removes duplicated nodes, since 'GetAllImageIDsOfControlPoint' only contains at most one of each node
   std::set_intersection(allImageIDsOfLesion.begin(), allImageIDsOfLesion.end(),
     allImageIDsOfControlPoint.begin(), allImageIDsOfControlPoint.end(),
     std::back_inserter(allImageIDsIntersection));
 
   // if the vector of intersecting image IDs is empty, the control point does not contain the lesion
   return !allImageIDsIntersection.empty();
 }
 
 bool mitk::SemanticRelationsInference::SpecificImageExists(const SemanticTypes::CaseID& caseID, const SemanticTypes::InformationType& informationType, const SemanticTypes::ControlPoint& controlPoint)
 {
   SemanticTypes::IDVector allImageIDsOfInformationType = RelationStorage::GetAllImageIDsOfInformationType(caseID, informationType);
   SemanticTypes::IDVector allImageIDsOfControlPoint = RelationStorage::GetAllImageIDsOfControlPoint(caseID, controlPoint);
 
   std::sort(allImageIDsOfInformationType.begin(), allImageIDsOfInformationType.end());
   std::sort(allImageIDsOfControlPoint.begin(), allImageIDsOfControlPoint.end());
   SemanticTypes::IDVector allImageIDsIntersection;
   // set_intersection removes duplicated nodes
   std::set_intersection(allImageIDsOfInformationType.begin(), allImageIDsOfInformationType.end(),
     allImageIDsOfControlPoint.begin(), allImageIDsOfControlPoint.end(),
     std::back_inserter(allImageIDsIntersection));
 
   // if the vector of intersecting image IDs is empty no image exists for the given information type and control point
   return !allImageIDsIntersection.empty();
 }
diff --git a/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp b/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
index c4f2923b2e..fddbc1637d 100644
--- a/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
@@ -1,298 +1,298 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations UI module
 #include "QmitkLesionTreeModel.h"
 
 // semantic relations module
 #include <mitkControlPointManager.h>
 #include <mitkLesionManager.h>
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsInference.h>
 #include <mitkRelationStorage.h>
 
 // qt
 #include <QColor>
 
 QmitkLesionTreeModel::QmitkLesionTreeModel(QObject* parent/* = nullptr*/)
   : QmitkAbstractSemanticRelationsStorageModel(parent)
   , m_LastSegmentation(nullptr)
   , m_RootItem(std::make_shared<QmitkLesionTreeItem>(mitk::LesionData()))
 {
   // nothing here
 }
 
 //////////////////////////////////////////////////////////////////////////
 // overridden virtual functions from QAbstractItemModel
 //////////////////////////////////////////////////////////////////////////
 QModelIndex QmitkLesionTreeModel::index(int row, int column, const QModelIndex& itemIndex) const
 {
   if (!hasIndex(row, column, itemIndex))
   {
     return QModelIndex();
   }
 
   auto childItem = GetItemByIndex(itemIndex)->GetChildInRow(row);
   if (nullptr == childItem)
   {
     return QModelIndex();
   }
 
   return createIndex(row, column, childItem.get());
 }
 
 QModelIndex QmitkLesionTreeModel::parent(const QModelIndex& itemIndex) const
 {
   if (!itemIndex.isValid())
   {
     return QModelIndex();
   }
 
   auto parentItem = GetItemByIndex(itemIndex)->GetParent();
   if (parentItem.expired())
   {
     return QModelIndex();
   }
 
   auto sharedParent = parentItem.lock();
   if (sharedParent == m_RootItem)
   {
     return QModelIndex();
   }
 
   return createIndex(sharedParent->GetRow(), 0, sharedParent.get());
 }
 
 int QmitkLesionTreeModel::rowCount(const QModelIndex& itemIndex/* = QModelIndex()*/) const
 {
   return GetItemByIndex(itemIndex)->ChildCount();
 }
 
 int QmitkLesionTreeModel::columnCount(const QModelIndex&/* itemIndex = QModelIndex() */) const
 {
   if (0 == m_RootItem->ChildCount())
   {
     // no lesion items stored, no need to display columns
     return 0;
   }
 
   return m_ControlPoints.size() + 1;
 }
 
 QVariant QmitkLesionTreeModel::data(const QModelIndex& index, int role) const
 {
   if (!index.isValid())
   {
     return QVariant();
   }
 
   if (index.column() < 0 || index.column() > static_cast<int>(m_ControlPoints.size()))
   {
     return QVariant();
   }
 
   QmitkLesionTreeItem* currentItem = GetItemByIndex(index);
   if (Qt::DisplayRole == role)
   {
     if (currentItem->GetParent().expired())
     {
       return QVariant();
     }
 
     auto parentItem = currentItem->GetParent().lock();
     // parent exists and is the root item -> 1. item of a lesion entry
     if (m_RootItem == parentItem)
     {
       // display role fills the first columns with the lesion UID / name
       if (0 == index.column())
       {
         std::string itemString = currentItem->GetData().GetLesionName();
         if (itemString.empty())
         {
           itemString = currentItem->GetData().GetLesionUID();
         }
         return QString::fromStdString(itemString);
       }
       else
       {
         // display role fills other columns with the lesion presence info
         const auto lesionPresence = currentItem->GetData().GetLesionPresence();
         if (index.column() - 1 > static_cast<int>(lesionPresence.size()))
         {
           return "N/A";
         }
 
         if (lesionPresence.at(index.column() - 1))
         {
           return QString::fromStdString("present");
         }
 
         return QString::fromStdString("not present");
       }
     }
   }
 
   if (Qt::BackgroundColorRole == role)
   {
     auto it = m_DataNodePresence.find(currentItem->GetData().GetLesion().UID);
     if (it != m_DataNodePresence.end())
     {
       return it->second ? QVariant(QColor(Qt::darkGreen)) : QVariant(QColor(Qt::transparent));
     }
 
     return QVariant(QColor(Qt::transparent));
   }
 
   if (Qt::UserRole == role)
   {
     return QVariant::fromValue(currentItem);
   }
 
   return QVariant();
 }
 
 QVariant QmitkLesionTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (0 == m_RootItem->ChildCount())
   {
     // no lesion items stored, no need to display the header
     return QVariant();
   }
 
   if (Qt::Horizontal == orientation && Qt::DisplayRole == role)
   {
     if (0 == section)
     {
       return QVariant("Lesion");
     }
 
     if (static_cast<int>(m_ControlPoints.size()) >= section)
     {
       mitk::SemanticTypes::ControlPoint currentControlPoint = m_ControlPoints.at(section-1);
       return QVariant(QString::fromStdString(currentControlPoint.ToString()));
     }
   }
 
   return QVariant();
 }
 
 const mitk::DataNode* QmitkLesionTreeModel::GetLastSegmentation() const
 {
   return m_LastSegmentation;
 }
 
 void QmitkLesionTreeModel::NodeAdded(const mitk::DataNode* dataNode)
 {
   if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
   {
     m_LastSegmentation = dataNode;
   }
 }
 
 void QmitkLesionTreeModel::SetData()
 {
   m_RootItem = std::make_shared<QmitkLesionTreeItem>(mitk::LesionData());
 
   // get all control points of current case
   m_ControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(m_CaseID);
   // sort the vector of control points for the timeline
   std::sort(m_ControlPoints.begin(), m_ControlPoints.end());
 
   SetLesionData();
   SetSelectedDataNodesPresence();
 }
 
 void QmitkLesionTreeModel::SetLesionData()
 {
   m_CurrentLesions = mitk::RelationStorage::GetAllLesionsOfCase(m_CaseID);
   for (auto& lesion : m_CurrentLesions)
   {
     AddLesion(lesion);
   }
 }
 
 void QmitkLesionTreeModel::AddLesion(const mitk::SemanticTypes::Lesion& lesion)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   // create new lesion tree item data and modify it according to the control point data
   mitk::LesionData lesionData(lesion);
   mitk::ComputeLesionPresence(lesionData, m_CaseID);
 
   // add the top-level lesion item to the root item
   std::shared_ptr<QmitkLesionTreeItem> newLesionTreeItem = std::make_shared<QmitkLesionTreeItem>(lesionData);
   m_RootItem->AddChild(newLesionTreeItem);
 }
 
 void QmitkLesionTreeModel::SetSelectedDataNodesPresence()
 {
   m_DataNodePresence.clear();
   for (const auto& dataNode : qAsConst(m_SelectedDataNodes))
   {
     if (!mitk::SemanticRelationsInference::InstanceExists(dataNode))
     {
       continue;
     }
 
     for (const auto& lesion : m_CurrentLesions)
     {
       if (!mitk::SemanticRelationsInference::InstanceExists(m_CaseID, lesion))
       {
         continue;
       }
       try
       {
         // set the lesion presence for the current node
         bool dataNodePresence = mitk::SemanticRelationsInference::IsLesionPresent(lesion, dataNode);
         SetDataNodePresenceOfLesion(&lesion, dataNodePresence);
       }
       catch (const mitk::SemanticRelationException&)
       {
         continue;
       }
     }
   }
 }
 
 void QmitkLesionTreeModel::SetDataNodePresenceOfLesion(const mitk::SemanticTypes::Lesion* lesion, bool dataNodePresence)
 {
   std::map<mitk::SemanticTypes::ID, bool>::iterator iter = m_DataNodePresence.find(lesion->UID);
   if (iter != m_DataNodePresence.end())
   {
     // key already existing, overwrite already stored bool value
     iter->second = dataNodePresence;
   }
   else
   {
     m_DataNodePresence.insert(std::make_pair(lesion->UID, dataNodePresence));
   }
 }
 
 QmitkLesionTreeItem* QmitkLesionTreeModel::GetItemByIndex(const QModelIndex& index) const
 {
   if (index.isValid())
   {
     auto item = static_cast<QmitkLesionTreeItem*>(index.internalPointer());
     if (nullptr != item)
     {
       return item;
     }
   }
 
   return m_RootItem.get();
 }
diff --git a/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp b/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
index 6edf5ae5df..96d48e69cb 100644
--- a/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkPatientTableInspector.cpp
@@ -1,179 +1,179 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations UI module
 #include "QmitkPatientTableInspector.h"
 #include "QmitkPatientTableHeaderView.h"
 
 // mitk qt widgets module
 #include "QmitkCustomVariants.h"
 #include "QmitkEnums.h"
 
 // qt
 #include <QKeyEvent>
 #include <QSignalMapper>
 
 QmitkPatientTableInspector::QmitkPatientTableInspector(QWidget* parent/* =nullptr*/)
   : QmitkAbstractSemanticRelationsStorageInspector(parent)
 {
   m_Controls.setupUi(this);
 
   QmitkPatientTableHeaderView* patientTableHeaderView = new QmitkPatientTableHeaderView(m_Controls.tableView);
   m_Controls.tableView->setHorizontalHeader(patientTableHeaderView);
   m_Controls.tableView->horizontalHeader()->setHighlightSections(false);
   m_Controls.tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Fixed);
   m_Controls.tableView->verticalHeader()->setHighlightSections(false);
   m_Controls.tableView->verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
   m_Controls.tableView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.tableView->setSelectionBehavior(QAbstractItemView::SelectItems);
   m_Controls.tableView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   m_StorageModel = new QmitkPatientTableModel(m_Controls.tableView);
   m_Controls.tableView->setModel(m_StorageModel);
   m_ItemDelegate = new QmitkTableItemThumbnailDelegate(m_Controls.tableView);
   //m_Controls.tableView->setItemDelegate(m_ItemDelegate);
 
   SetUpConnections();
 }
 
 QAbstractItemView* QmitkPatientTableInspector::GetView()
 {
   return m_Controls.tableView;
 }
 
 const QAbstractItemView* QmitkPatientTableInspector::GetView() const
 {
   return m_Controls.tableView;
 }
 
 void QmitkPatientTableInspector::SetSelectionMode(SelectionMode mode)
 {
   m_Controls.tableView->setSelectionMode(mode);
 }
 
 QmitkPatientTableInspector::SelectionMode QmitkPatientTableInspector::GetSelectionMode() const
 {
   return m_Controls.tableView->selectionMode();
 }
 
 void QmitkPatientTableInspector::SetCaseID(const mitk::SemanticTypes::CaseID& caseID)
 {
   m_StorageModel->SetCaseID(caseID);
 }
 
 void QmitkPatientTableInspector::SetLesion(const mitk::SemanticTypes::Lesion& lesion)
 {
   m_StorageModel->SetLesion(lesion);
 }
 
 QItemSelectionModel* QmitkPatientTableInspector::GetSelectionModel()
 {
   return m_Controls.tableView->selectionModel();
 }
 
 void QmitkPatientTableInspector::Initialize()
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   m_StorageModel->SetDataStorage(dataStorage);
   m_StorageModel->SetNodePredicate(m_NodePredicate);
 
   m_Connector->SetView(m_Controls.tableView);
 }
 
 void QmitkPatientTableInspector::OnModelUpdated()
 {
   m_Controls.tableView->resizeRowsToContents();
   m_Controls.tableView->resizeColumnsToContents();
 }
 
 void QmitkPatientTableInspector::OnNodeButtonClicked(const QString& nodeType)
 {
   m_StorageModel->SetNodeType(nodeType.toStdString());
 }
 
 void QmitkPatientTableInspector::OnDataNodeSelectionChanged(const QList<mitk::DataNode::Pointer>& dataNodeSelection)
 {
   if (m_StorageModel->GetLesion().UID.empty())
   {
     return;
   }
 
   // if lesion is set, reset to empty lesion to hide the "lesion presence background highlighting" in the model
   m_StorageModel->SetLesion(mitk::SemanticTypes::Lesion());
   // need to explicitly set the data node selection
   SetCurrentSelection(dataNodeSelection);
 }
 
 void QmitkPatientTableInspector::OnItemDoubleClicked(const QModelIndex& itemIndex)
 {
   if (itemIndex.isValid())
   {
     QVariant qvariantDataNode = m_StorageModel->data(itemIndex, QmitkDataNodeRawPointerRole);
     if (qvariantDataNode.canConvert<mitk::DataNode*>())
     {
       mitk::DataNode* dataNode = qvariantDataNode.value<mitk::DataNode*>();
       emit DataNodeDoubleClicked(dataNode);
     }
   }
 }
 
 void QmitkPatientTableInspector::SetUpConnections()
 {
   connect(m_StorageModel, &QmitkPatientTableModel::ModelUpdated, this, &QmitkPatientTableInspector::OnModelUpdated);
   connect(m_Controls.tableView, &QTableView::customContextMenuRequested, this, &QmitkPatientTableInspector::OnContextMenuRequested);
 
   QSignalMapper* nodeButtonSignalMapper = new QSignalMapper(this);
   nodeButtonSignalMapper->setMapping(m_Controls.imageNodeButton, QString("Image"));
   nodeButtonSignalMapper->setMapping(m_Controls.segmentationNodeButton, QString("Segmentation"));
   connect(nodeButtonSignalMapper, static_cast<void (QSignalMapper::*)(const QString&)>(&QSignalMapper::mapped), this, &QmitkPatientTableInspector::OnNodeButtonClicked);
   connect(m_Controls.imageNodeButton, &QRadioButton::clicked, nodeButtonSignalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
   connect(m_Controls.segmentationNodeButton, &QRadioButton::clicked, nodeButtonSignalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
   m_Controls.imageNodeButton->setChecked(true);
 
   connect(this, &QmitkPatientTableInspector::CurrentSelectionChanged, this, &QmitkPatientTableInspector::OnDataNodeSelectionChanged);
   connect(m_Controls.tableView, &QTableView::doubleClicked, this, &QmitkPatientTableInspector::OnItemDoubleClicked);
 }
 
 void QmitkPatientTableInspector::keyPressEvent(QKeyEvent* e)
 {
   mitk::DataNode* dataNode = nullptr;
   QModelIndex selectedIndex = m_Controls.tableView->currentIndex();
   if (selectedIndex.isValid())
   {
     QVariant qvariantDataNode = m_StorageModel->data(selectedIndex, QmitkDataNodeRawPointerRole);
     if (qvariantDataNode.canConvert<mitk::DataNode*>())
     {
       dataNode = qvariantDataNode.value<mitk::DataNode*>();
     }
   }
 
   if (nullptr == dataNode)
   {
     return;
   }
 
   int key = e->key();
   switch (key)
   {
   case Qt::Key_Delete:
     emit OnNodeRemoved(dataNode);
     break;
   default:
     break;
   }
 }
diff --git a/Modules/SemanticRelationsUI/src/QmitkStatisticsCalculator.cpp b/Modules/SemanticRelationsUI/src/QmitkStatisticsCalculator.cpp
index 0caa074875..01e9882c3b 100644
--- a/Modules/SemanticRelationsUI/src/QmitkStatisticsCalculator.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkStatisticsCalculator.cpp
@@ -1,233 +1,232 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations UI module
 #include "QmitkStatisticsCalculator.h"
 
 // semantic relations module
 #include <mitkNodePredicates.h>
 #include <mitkRelationStorage.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsDataStorageAccess.h>
 #include <mitkSemanticRelationsInference.h>
 
 // mitk image statistics module
 #include <mitkImageStatisticsContainerManager.h>
 #include <mitkImageStatisticsContainerNodeHelper.h>
 #include <mitkStatisticsToImageRelationRule.h>
 #include <mitkStatisticsToMaskRelationRule.h>
 
 QmitkStatisticsCalculator::QmitkStatisticsCalculator()
   : m_CalculationJob(nullptr)
   , m_DataStorage(nullptr)
   , m_MaskVolume(0.0)
 {
   m_CalculationJob = new QmitkImageStatisticsCalculationJob();
 
   connect(m_CalculationJob, &QmitkImageStatisticsCalculationJob::finished, this,
     &QmitkStatisticsCalculator::OnStatisticsCalculationEnds, Qt::QueuedConnection);
 }
 
 QmitkStatisticsCalculator::~QmitkStatisticsCalculator()
 {
   if (!m_CalculationJob->isFinished())
   {
     m_CalculationJob->terminate();
     m_CalculationJob->wait();
   }
   m_CalculationJob->deleteLater();
 }
 
 void QmitkStatisticsCalculator::ComputeLesionVolume(mitk::LesionData& lesionData, const mitk::SemanticTypes::CaseID& caseID)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   std::vector<double> lesionVolume;
   mitk::SemanticTypes::Lesion lesion = lesionData.GetLesion();
   double volume = 0.0;
 
   mitk::SemanticTypes::ControlPointVector controlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(caseID);
   // sort the vector of control points for the timeline
   std::sort(controlPoints.begin(), controlPoints.end());
   mitk::SemanticTypes::InformationTypeVector informationTypes = mitk::RelationStorage::GetAllInformationTypesOfCase(caseID);
   for (const auto& informationType : informationTypes)
   {
     for (const auto& controlPoint : controlPoints)
     {
       mitk::SemanticRelationsDataStorageAccess semanticRelationsDataStorageAccess(dataStorage);
       mitk::DataNode::Pointer specificImage;
       mitk::DataNode::Pointer specificSegmentation;
       try
       {
         specificSegmentation = semanticRelationsDataStorageAccess.GetSpecificSegmentation(caseID, controlPoint, informationType, lesion);
         if (nullptr == specificSegmentation)
         {
           volume = 0.0;
         }
         else
         {
           // get parent node of the specific segmentation node with the node predicate
           auto parentNodes = dataStorage->GetSources(specificSegmentation, mitk::NodePredicates::GetImagePredicate(), false);
           for (auto it = parentNodes->Begin(); it != parentNodes->End(); ++it)
           {
             specificImage = it->Value();
           }
 
           volume = GetSegmentationMaskVolume(specificImage, specificSegmentation);
         }
       }
       catch (mitk::SemanticRelationException&)
       {
         volume = 0.0;
       }
 
       lesionVolume.push_back(volume);
     }
   }
 
   lesionData.SetLesionVolume(lesionVolume);
 }
 
 double QmitkStatisticsCalculator::GetSegmentationMaskVolume(mitk::DataNode::Pointer imageNode, mitk::DataNode::Pointer segmentationNode)
 {
   m_MaskVolume = 0.0;
+  auto dataStorage = m_DataStorage.Lock();
 
-  if (m_DataStorage.IsExpired())
+  if (dataStorage.IsNull())
   {
     return m_MaskVolume;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   if (imageNode.IsNull() || segmentationNode.IsNull())
   {
     return m_MaskVolume;
   }
 
   m_ImageNode = imageNode;
   m_SegmentationNode = segmentationNode;
 
   auto image = dynamic_cast<mitk::Image*>(m_ImageNode->GetData());
   auto segmentation = dynamic_cast<mitk::Image*>(m_SegmentationNode->GetData());
   if (nullptr == image || nullptr == segmentation)
   {
     return m_MaskVolume;
   }
 
   // all nodes and images are valid, retrieve statistics
   mitk::ImageStatisticsContainer::ConstPointer imageStatistics = mitk::ImageStatisticsContainerManager::GetImageStatistics(dataStorage, image, segmentation).GetPointer();
 
   bool imageStatisticsOlderThanInputs = false;
   if (imageStatistics && (imageStatistics->GetMTime() < image->GetMTime() || (imageStatistics->GetMTime() < segmentation->GetMTime())))
   {
     imageStatisticsOlderThanInputs = true;
   }
   // statistics need to be (re)computed
   if (!imageStatistics || imageStatisticsOlderThanInputs)
   {
     m_CalculationJob->Initialize(image, segmentation, nullptr);
     try
     {
       m_CalculationJob->start();
       return m_MaskVolume;
     }
     catch (const std::exception&)
     {
       return m_MaskVolume;
     }
   }
 
   // use a valid statistics object to get the volume of the image-segmentation pair
   mitk::ImageStatisticsContainer::ImageStatisticsObject statisticsObject;
   try
   {
     statisticsObject = imageStatistics->GetStatisticsForTimeStep(0);
   }
   catch (mitk::Exception&)
   {
     return m_MaskVolume;
   }
   try
   {
     if (statisticsObject.HasStatistic(mitk::ImageStatisticsConstants::VOLUME()))
     {
       auto valueVariant = statisticsObject.GetValueNonConverted(mitk::ImageStatisticsConstants::VOLUME());
       m_MaskVolume = boost::get<double>(valueVariant);
     }
   }
   catch (mitk::Exception&)
   {
     return m_MaskVolume;
   }
 
   return m_MaskVolume;
 }
 
 void QmitkStatisticsCalculator::OnStatisticsCalculationEnds()
 {
   // taken from 'QmitkImageStatisticsView' (see measurementtoolbox plugin)
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   if (m_CalculationJob->GetStatisticsUpdateSuccessFlag())
   {
     auto statistic = m_CalculationJob->GetStatisticsData();
     auto image = m_CalculationJob->GetStatisticsImage();
     mitk::BaseData::ConstPointer mask = nullptr;
     auto imageRule = mitk::StatisticsToImageRelationRule::New();
     imageRule->Connect(statistic, image);
 
     if (m_CalculationJob->GetMaskImage())
     {
       auto maskRule = mitk::StatisticsToMaskRelationRule::New();
       mask = m_CalculationJob->GetMaskImage();
       maskRule->Connect(statistic, mask);
     }
 
     auto imageStatistics = mitk::ImageStatisticsContainerManager::GetImageStatistics(dataStorage, image, mask);
 
     // if statistics base data already exist: add to existing node
     if (nullptr != imageStatistics)
     {
       auto allDataNodes = dataStorage->GetAll()->CastToSTLConstContainer();
       for (auto node : allDataNodes)
       {
         auto nodeData = node->GetData();
         if (nullptr != nodeData && nodeData->GetUID() == imageStatistics->GetUID())
         {
           node->SetData(statistic);
         }
       }
     }
     // statistics base data does not exist: add new node
     else
     {
       auto statisticsNodeName = m_ImageNode->GetName();
       if (m_SegmentationNode)
       {
         statisticsNodeName += "_" + m_SegmentationNode->GetName();
       }
       statisticsNodeName += "_statistics";
       auto statisticsNode = mitk::CreateImageStatisticsNode(statistic, statisticsNodeName);
       dataStorage->Add(statisticsNode);
     }
   }
 }
diff --git a/Modules/SemanticRelationsUI/src/QmitkStatisticsTreeModel.cpp b/Modules/SemanticRelationsUI/src/QmitkStatisticsTreeModel.cpp
index fba6ca57f6..110bff79dc 100644
--- a/Modules/SemanticRelationsUI/src/QmitkStatisticsTreeModel.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkStatisticsTreeModel.cpp
@@ -1,267 +1,268 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations UI module
 #include "QmitkStatisticsTreeModel.h"
 
 // semantic relations module
 #include <mitkControlPointManager.h>
 #include <mitkLesionManager.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsInference.h>
 #include <mitkRelationStorage.h>
 
 QmitkStatisticsTreeModel::QmitkStatisticsTreeModel(QObject* parent/* = nullptr*/)
   : QmitkAbstractSemanticRelationsStorageModel(parent)
   , m_RootItem(std::make_shared<QmitkLesionTreeItem>(mitk::LesionData()))
 {
   m_StatisticsCalculator = std::make_unique<QmitkStatisticsCalculator>();
 }
 
 //////////////////////////////////////////////////////////////////////////
 // overridden virtual functions from QAbstractItemModel
 //////////////////////////////////////////////////////////////////////////
 QModelIndex QmitkStatisticsTreeModel::index(int row, int column, const QModelIndex& itemIndex) const
 {
   if (!hasIndex(row, column, itemIndex))
   {
     return QModelIndex();
   }
 
   auto childItem = GetItemByIndex(itemIndex)->GetChildInRow(row);
   if (nullptr == childItem)
   {
     return QModelIndex();
   }
 
   return createIndex(row, column, childItem.get());
 }
 
 QModelIndex QmitkStatisticsTreeModel::parent(const QModelIndex& itemIndex) const
 {
   if (!itemIndex.isValid())
   {
     return QModelIndex();
   }
 
   auto parentItemWeakPtr = GetItemByIndex(itemIndex)->GetParent();
   if (parentItemWeakPtr.expired())
   {
     return QModelIndex();
   }
 
   auto parentItem = parentItemWeakPtr.lock();
   if (parentItem == m_RootItem)
   {
     return QModelIndex();
   }
 
   return createIndex(parentItem->GetRow(), 0, parentItem.get());
 }
 
 int QmitkStatisticsTreeModel::rowCount(const QModelIndex& itemIndex/* = QModelIndex()*/) const
 {
   return GetItemByIndex(itemIndex)->ChildCount();
 }
 
 int QmitkStatisticsTreeModel::columnCount(const QModelIndex&/* itemIndex = QModelIndex() */) const
 {
   if (0 == m_RootItem->ChildCount())
   {
     // no lesion items stored, no need to display columns
     return 0;
   }
 
   return m_ControlPoints.size() + 1;
 }
 
 QVariant QmitkStatisticsTreeModel::data(const QModelIndex& index, int role) const
 {
   if (!index.isValid())
   {
     return QVariant();
   }
 
   if (index.column() < 0 || index.column() > static_cast<int>(m_ControlPoints.size()))
   {
     return QVariant();
   }
 
   QmitkLesionTreeItem* currentItem = GetItemByIndex(index);
   if (Qt::DisplayRole == role)
   {
     if (currentItem->GetParent().expired())
     {
       return QVariant();
     }
 
     auto parentItem = currentItem->GetParent().lock();
     // parent exists and is the root item -> top level item
     if (m_RootItem == parentItem)
     {
       // display role fills the first columns with the lesion UID / name
       if (0 == index.column())
       {
         std::string itemString = currentItem->GetData().GetLesionName();
         if (itemString.empty())
         {
           itemString = currentItem->GetData().GetLesionUID();
         }
         return QString::fromStdString(itemString);
       }
     }
     // parent is not the root item -> volume item
     else
     {
       // display role fills the first columns with the information type
       if (0 == index.column())
       {
         if (index.row() < static_cast<int>(m_InformationTypes.size()))
         {
           return QString::fromStdString(m_InformationTypes.at(index.row()));
         }
         return "N/A";
       }
       else
       {
         // display role fills other columns with the lesion volume info
         const auto lesionVolume = currentItem->GetData().GetLesionVolume();
         if ((index.column() - 1) * index.row() < static_cast<int>(lesionVolume.size()))
         {
           return QVariant(lesionVolume.at(index.row()*m_ControlPoints.size() + (index.column() - 1)));
         }
         return "N/A";
       }
     }
   }
 
   return QVariant();
 }
 
 QVariant QmitkStatisticsTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (0 == m_RootItem->ChildCount())
   {
     // no lesion items stored, no need to display the header
     return QVariant();
   }
 
   if (Qt::Horizontal == orientation && Qt::DisplayRole == role)
   {
     if (0 == section)
     {
       return QVariant("Lesion");
     }
 
     if (static_cast<int>(m_ControlPoints.size()) >= section)
     {
       mitk::SemanticTypes::ControlPoint currentControlPoint = m_ControlPoints.at(section-1);
       return QVariant(QString::fromStdString(currentControlPoint.ToString()));
     }
   }
 
   return QVariant();
 }
 
 void QmitkStatisticsTreeModel::DataStorageChanged()
 {
-  if (!m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNotNull())
   {
-    auto dataStorage = m_DataStorage.Lock();
     m_SemanticRelationsDataStorageAccess = std::make_unique<mitk::SemanticRelationsDataStorageAccess>(dataStorage);
     m_StatisticsCalculator->SetDataStorage(dataStorage);
     UpdateModelData();
   }
 }
 
 void QmitkStatisticsTreeModel::NodeAdded(const mitk::DataNode*)
 {
   emit beginResetModel();
   UpdateModelData();
   emit endResetModel();
 }
 
 void QmitkStatisticsTreeModel::NodeChanged(const mitk::DataNode*)
 {
   emit beginResetModel();
   UpdateModelData();
   emit endResetModel();
 }
 
 void QmitkStatisticsTreeModel::NodeRemoved(const mitk::DataNode*)
 {
   emit beginResetModel();
   UpdateModelData();
   emit endResetModel();
 }
 
 void QmitkStatisticsTreeModel::SetData()
 {
   m_RootItem = std::make_shared<QmitkLesionTreeItem>(mitk::LesionData());
 
   // get all control points of current case
   m_ControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(m_CaseID);
   // sort the vector of control points for the timeline
   std::sort(m_ControlPoints.begin(), m_ControlPoints.end());
 
   // get all information types points of current case
   m_InformationTypes = mitk::RelationStorage::GetAllInformationTypesOfCase(m_CaseID);
 
   SetLesionData();
 }
 
 void QmitkStatisticsTreeModel::SetLesionData()
 {
   m_CurrentLesions = mitk::RelationStorage::GetAllLesionsOfCase(m_CaseID);
   for (auto& lesion : m_CurrentLesions)
   {
     AddLesion(lesion);
   }
 }
 
 void QmitkStatisticsTreeModel::AddLesion(const mitk::SemanticTypes::Lesion& lesion)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   // create new lesion tree item data and modify it according to the control point data
   mitk::LesionData lesionData(lesion);
   m_StatisticsCalculator->ComputeLesionVolume(lesionData, m_CaseID);
 
   // add the 1. level lesion item to the root item
   std::shared_ptr<QmitkLesionTreeItem> newLesionTreeItem = std::make_shared<QmitkLesionTreeItem>(lesionData);
   m_RootItem->AddChild(newLesionTreeItem);
 
   for (size_t i = 0; i < m_InformationTypes.size(); ++i)
   {
     std::shared_ptr<QmitkLesionTreeItem> volumeItem = std::make_shared<QmitkLesionTreeItem>(lesionData);
     newLesionTreeItem->AddChild(volumeItem);
   }
 }
 
 QmitkLesionTreeItem* QmitkStatisticsTreeModel::GetItemByIndex(const QModelIndex& index) const
 {
   if (index.isValid())
   {
     auto item = static_cast<QmitkLesionTreeItem*>(index.internalPointer());
     if (nullptr != item)
     {
       return item;
     }
   }
 
   return m_RootItem.get();
 }
diff --git a/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.h b/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.h
index e4739df3da..ca837ef7ba 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.h
@@ -1,185 +1,183 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef _QMITKTOFRECORDERWIDGET_H_INCLUDED
 #define _QMITKTOFRECORDERWIDGET_H_INCLUDED
 
 #include <MitkToFUIExports.h>
 #include <ui_QmitkToFRecorderWidgetControls.h>
 
 //QT headers
 #include <QWidget>
 #include <QString>
 #include <QDialog>
 #include <QFileDialog>
 
 //itk headers
 #include "itkCommand.h"
 
 //mitk headers
 #include <mitkToFImageGrabber.h>
 #include <mitkToFImageRecorder.h>
 
-class QmitkStdMultiWidget;
-
 struct QFileDialogArgs;
 class QFileIconProvider;
 class QFileDialogPrivate;
 
 /**
 * @brief Widget allowing to play / record ToF data
 *
 * @ingroup ToFUI
 */
 class MITKTOFUI_EXPORT QmitkToFRecorderWidget :public QWidget
 {
 
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkToFRecorderWidget(QWidget* p = nullptr, Qt::WindowFlags f1 = nullptr);
     ~QmitkToFRecorderWidget() override;
 
     /* @brief This method is part of the widget an needs not to be called seperately. */
     virtual void CreateQtPartControl(QWidget *parent);
     /* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
     virtual void CreateConnections();
 
     /*!
     \brief Set the parameters used for this widget
     \param ToFImageGrabber image grabber providing images from a ToF device
     \param toFImageRecorder image recorder allowing to record ToF images
     */
     void SetParameter(mitk::ToFImageGrabber* ToFImageGrabber,  mitk::ToFImageRecorder* toFImageRecorder);
     /*!
     \brief resets the GUI elements to the initial state. Play button: enabled, Stop button: disabled, Recording box: disabled
     */
     void ResetGUIToInitial();
 
   signals:
     /*!
     \brief signal emitted when "Play" button is pressed
     */
     void ToFCameraStarted();
     /*!
     \brief signal emitted when "Stop" button is pressed
     */
     void ToFCameraStopped();
     /*!
     \brief signal emitted when recording is started
     */
     void RecordingStarted();
     /*!
     \brief signal emitted AbortEvent() in ToFImageRecorder is observed
     */
     void RecordingStopped();
 
   public slots:
     /*!
     \brief slot invoking to start the camera.
     Calls StartCamera() and emits ToFCameraStarted signal
     */
     void OnPlay();
     /*!
     \brief slot invoking to stop the camera and the recorder.
     Calls StopCamera() and StopRecorder and emits ToFCameraStarted signal. Resets GUI to initial state.
     */
     void OnStop();
     /*!
     \brief slot invoking to start the recording
     After letting the user chose a file location for the record, m_ImageRecorder->StartRecording() is inoved.
     */
     void OnStartRecorder();
     /*!
     \brief slot resetting the GUI elements of the recording box
     */
     void OnRecordingStopped();
     /*!
     \brief slot activating/deactivating "number of frames" spin box dependent on recording mode (PerFrame / Infinite)
     */
     void OnChangeRecordModeComboBox(int index);
 
   protected:
 
     /*!
     \brief starts the camera by calling ToFImageGrabber::StartCamera()
     */
     void StartCamera();
     /*!
     \brief stops the camera by calling ToFImageGrabber::StopCamera()
     */
     void StopCamera();
     /*!
     \brief stops the recording by calling ToFImageRecorder::StopRecording()
     */
     void StopRecorder();
     /*!
     \brief emits RecordingStopped signal.
     */
     void StopRecordingCallback();
     /*!
     \brief adapted version of QFileDialog::getSaveFileName()
     The user is now asked to choose which images he wants to save
     (Distance and/or Intensity and/or Amplitude image) and which type the saved
     image should have (3D, 2D+t).
     */
     static QString getSaveFileName(mitk::ToFImageWriter::ToFImageType& tofImageType,
                                    bool& distanceImageSelected,
                                    bool& amplitudeImageSelected,
                                    bool& intensityImageSelected,
                                    bool& rgbImageSelected,
                                    bool& rawDataSelected,
                                    QWidget *parent = nullptr,
                                    const QString &caption = QString(),
                                    const QString &dir = QString(),
                                    const QString &filter = QString(),
                                    QString *selectedFilter = nullptr,
                                    QFileDialog::Options options = nullptr
                                    );
     /*!
     \brief method creating a filename from the given information
     \param dir directory to save the file
     \param baseFilename base file name entered by the user
     \param modulationFreq modulation frequency of the camera
     \param integrationTime integration time of the camera
     \param numOfFrames number of frames recorded
     \param extension file extension
     \param imageType type of image (DistanceImage, IntensityImage, AmplitudeImage)
     \return dir+"/"+baseFilename+"_MF"+modulationFreq+"_IT"+integrationTime+"_"+numOfFrames+"Images"+imageType+extension
     */
     std::string prepareFilename(std::string dir,
                                 std::string baseFilename,
                                 std::string modulationFreq,
                                 std::string integrationTime,
                                 std::string numOfFrames,
                                 std::string extension,
                                 std::string imageType);
 
     Ui::QmitkToFRecorderWidgetControls* m_Controls; ///< member holding the UI elements of this widget
 
     mitk::ToFImageGrabber::Pointer m_ToFImageGrabber; ///< member holding the ToFImageGrabber for acquiring ToF images
     mitk::ToFImageRecorder::Pointer m_ToFImageRecorder; ///< member holding the recorder for ToF images
 
     mitk::ToFImageRecorder::RecordMode m_RecordMode; ///< member holding the RecordMode of the recorder (PerFrame / Infinite)
 
     typedef itk::SimpleMemberCommand<QmitkToFRecorderWidget> CommandType;
     CommandType::Pointer m_StopRecordingCommand; ///< itkCommand for abort of recording
 
   private:
 
 };
 
 #endif // _QMITKTOFRECORDERWIDGET_H_INCLUDED
diff --git a/Modules/ToFUI/Qmitk/QmitkToFSurfaceGenerationWidget.h b/Modules/ToFUI/Qmitk/QmitkToFSurfaceGenerationWidget.h
index d5f41cd42b..762751ebbd 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFSurfaceGenerationWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkToFSurfaceGenerationWidget.h
@@ -1,157 +1,155 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef _QMITKTOFSURFACEGENERATIONWIDGET_H_INCLUDED
 #define _QMITKTOFSURFACEGENERATIONWIDGET_H_INCLUDED
 
 #include <MitkToFUIExports.h>
 #include "ui_QmitkToFSurfaceGenerationWidgetControls.h"
 
 // QT headers
 #include <QWidget>
 
 // vtk includes
 #include <vtkColorTransferFunction.h>
 #include <vtkCamera.h>
 #include <vtkSmartPointer.h>
 
 //MITK
 #include <mitkDataNode.h>
 #include <mitkToFDistanceImageToSurfaceFilter.h>
 #include <mitkToFImageGrabber.h>
 #include <mitkCameraIntrinsics.h>
 #include <mitkSurface.h>
 
-class QmitkStdMultiWidget;
-
 /** Documentation:
   *
   * This widget provides GUI access for all basic surface generation properties and can
   * be reused in any other GUI.
   * \ingroup ToFUI
   */
 class MITKTOFUI_EXPORT QmitkToFSurfaceGenerationWidget :public QWidget
 {
 
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkToFSurfaceGenerationWidget (QWidget* p = nullptr, Qt::WindowFlags f1 = nullptr);
     ~QmitkToFSurfaceGenerationWidget () override;
 
     /* @brief Automatically called method. */
     virtual void CreateQtPartControl(QWidget *parent);
     /* @brief Automatically called method. Creation of the connections of main and control widget.)*/
     virtual void CreateConnections();
 
 
     /**
      * @brief GetToFDistanceImageToSurfaceFilter Get the internally used surface generation filter.
      * @return ToFDistanceImageToSurfaceFilter as filter.
      */
     mitk::ToFDistanceImageToSurfaceFilter::Pointer GetToFDistanceImageToSurfaceFilter();
 
     /**
      * @brief IsActive Check if the widget was initialized correctly.
      * @return True for success.
      */
     bool IsActive();
 
     /**
      * @brief Initialize Initialize the surface generation widget.
      * @param filter ToFDistanceImageToSurfaceFilter for surface computation.
      * @param grabber ToFImageGrabber to get/set device properties.
      * @param intrinsics Intrincs of the device.
      * @param surface Generated Surface.
      * @param camera
      * @param generateSurface Check the generate surface combo box.
      * @param showAdvancedOptions Show/Hide advanced options.
      */
     void Initialize(mitk::ToFDistanceImageToSurfaceFilter::Pointer filter, mitk::ToFImageGrabber::Pointer grabber, mitk::CameraIntrinsics::Pointer intrinsics,
       mitk::DataNode::Pointer surface, vtkSmartPointer<vtkCamera> camera, bool generateSurface = false, bool showAdvancedOptions = true);
 
     /**
      * @brief UpdateSurface Generate new surface data according to the device properties
      * @return True for success.
      */
     bool UpdateSurface();
 
     /**
      * @brief GetSurface Get the generated surface.
      * @return Surface.
      */
     mitk::Surface::Pointer GetSurface();
 
 protected slots:
     /**
      * @brief OnRepresentationChanged Change the representation of the surface. In other words: disable/enable
      * triangulation (Point cloud/surface). If triangulation is enabled, this will also allow for editing a
      * threshold for triangulating vertices.
      */
     void OnRepresentationChanged(int index);
     /**
      * @brief OnReconstructionChanged Change the reconstruction mode of the ToFDistanceImageToSurfaceFilter.
      */
     void OnReconstructionChanged(int index);
 
     /**
      * @brief OnCompute3DDataCheckboxChecked Slot beeing called, if the "surface"-checkbox is clicked. This method initializes the surface once, if it is necessary.
      * @param checked Is it checked or not?
      */
     void OnCompute3DDataCheckboxChecked(bool checked);
     /**
      * @brief OnShowAdvancedOptionsCheckboxChecked Show/hide advanced options.
      * @param checked show/hide
      */
     void OnShowAdvancedOptionsCheckboxChecked(bool checked);
 
     /*!
       \brief Slot trigged from the triangulation threshold spin box. Changed the threshold for connecting a vertex during triangulation.
       */
     void OnTriangulationThresholdSpinBoxChanged();
 
     /**
      * @brief OnDistanceColorMapCheckBoxChecked Show the distance color mapping (vtkColorTransferFunction) on the surface.
      * @param checked Show/hide.
      */
     void OnDistanceColorMapCheckBoxChecked(bool checked);
 
     /**
      * @brief OnRGBTextureCheckBoxChecked Put the RGB image as texture on the generated surface/point cloud.
      * @param checked Show/hide texture.
      */
     void OnRGBTextureCheckBoxChecked(bool checked);
 
 
   protected:
 
     Ui::QmitkToFSurfaceGenerationWidgetControls* m_Controls;
 
 
   private:
     void FindReconstructionModeProperty();
 
     mitk::ToFDistanceImageToSurfaceFilter::Pointer m_ToFDistanceImageToSurfaceFilter;
     mitk::ToFImageGrabber::Pointer m_ToFImageGrabber;
     mitk::CameraIntrinsics::Pointer m_CameraIntrinsics;
     mitk::DataNode::Pointer m_SurfaceNode;
     mitk::Surface::Pointer m_Surface;
     bool m_Active;
     vtkSmartPointer<vtkCamera> m_Camera3d;
 
 };
 
 #endif // _QMITKTOFVISUALISATIONSETTINGSWIDGET_H_INCLUDED
diff --git a/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.h b/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.h
index 2e86190d4f..b888b4222e 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.h
@@ -1,172 +1,170 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef _QMITKTOFVISUALISATIONSETTINGSWIDGET_H_INCLUDED
 #define _QMITKTOFVISUALISATIONSETTINGSWIDGET_H_INCLUDED
 
 #include <MitkToFUIExports.h>
 #include "ui_QmitkToFVisualisationSettingsWidgetControls.h"
 
 #include "mitkDataNode.h"
 // QT headers
 #include <QWidget>
 // vtk includes
 #include <vtkColorTransferFunction.h>
 
-class QmitkStdMultiWidget;
-
 /** Documentation:
   * Widget controlling the visualization of Time-of-Flight image data. A color transfer function can be configured for
   * a given distance, amplitude and intensity image. The pre-configured vtkColorTransferFunctions can be accessed as
   * an output of the widget.
   *
   * \ingroup ToFUI
   */
 class MITKTOFUI_EXPORT QmitkToFVisualisationSettingsWidget :public QWidget
 {
 
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkToFVisualisationSettingsWidget (QWidget* p = nullptr, Qt::WindowFlags f1 = nullptr);
     ~QmitkToFVisualisationSettingsWidget () override;
 
     /* @brief This method is part of the widget an needs not to be called seperately. */
     virtual void CreateQtPartControl(QWidget *parent);
     /* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
     virtual void CreateConnections();
     /*!
     \brief initialize the widget with the images to be shown
     \param distanceImageNode image holding the range image of a ToF camera
     \param amplitudeImageNode image holding the amplitude image of a ToF camera
     \param intensityImageNode image holding the intensity image of a ToF camera
     \param surfaceNode
     */
     void Initialize(mitk::DataNode* distanceImageNode=nullptr, mitk::DataNode* amplitudeImageNode=nullptr,
                     mitk::DataNode* intensityImageNode=nullptr, mitk::DataNode* surfaceNode=nullptr);
 
     /*!
     \brief Access the color transfer function of widget 1 (distance image)
     \return vtkColorTransferFunction that can be used to define a TransferFunctionProperty
     */
     vtkColorTransferFunction* GetWidget1ColorTransferFunction();
     /*!
     \brief Access the color transfer function of widget 2 (distance image)
     \return vtkColorTransferFunction that can be used to define a TransferFunctionProperty
     */
     vtkColorTransferFunction* GetWidget2ColorTransferFunction();
     /*!
     \brief Access the color transfer function of widget 3 (distance image)
     \return vtkColorTransferFunction that can be used to define a TransferFunctionProperty
     */
     vtkColorTransferFunction* GetWidget3ColorTransferFunction();
     /*!
     \brief Access the color transfer of the currently selected widget
     \return vtkColorTransferFunction that can be used to define a TransferFunctionProperty
     */
     vtkColorTransferFunction* GetSelectedColorTransferFunction();
     /*!
     \brief Return the index of the selected image: 0 = Distance, 1 = Amplitude, 2 = Intensity
     */
     int GetSelectedImageIndex();
 
 protected slots:
     void OnShowAdvancedOptionsCheckboxChecked(bool checked);
 
     void OnSetXValueColor();
     /*!
     \brief Slot invoking a reset of the RangeSlider to the minimal and maximal values of the according image
     */
     void OnResetSlider();
     /*!
     \brief Slot called when the range span has changed.
     */
     void OnSpanChanged (int lower, int upper);
     /*!
     \brief Resets the transfer function according to the currently selected widget / image
     */
     void OnTransferFunctionReset();
     /*!
     \brief Updates the GUI according to the widget / image selection
     */
     void OnWidgetSelected(int index);
     /*!
     \brief Slot called when the line edit of the maximal value of the range slider has changed. Leads to an update of the range slider.
     */
     void OnRangeSliderMaxChanged();
     /*!
     \brief Slot called when the line edit of the minimal value of the range slider has changed. Leads to an update of the range slider.
     */
     void OnRangeSliderMinChanged();
     /*!
     \brief Sets the TransferFunctionType members according to the selection of the widget and the transfer type.
     */
     void OnTransferFunctionTypeSelected(int index);
 
   protected:
 
     /*!
     \brief Invokes an update of the ColorTransferFunctionCanvas. Called when the ColorTransferFunction has changed
     */
     void UpdateCanvas();
     /*!
     \brief Resets the ColorTransferFunctionCanvas according to the lower and upper value of the RangeSlider
     */
     void UpdateRanges();
 
     Ui::QmitkToFVisualisationSettingsWidgetControls* m_Controls;
 
     int m_RangeSliderMin; ///< Minimal value of the transfer function range. Initialized to the minimal value of the corresponding image.
     int m_RangeSliderMax; ///< Maximal value of the transfer function range. Initialized to the maximal value of the corresponding image.
 
     mitk::DataNode::Pointer m_MitkDistanceImageNode; ///< DataNode holding the range image of the ToF camera as set by Initialize()
     mitk::DataNode::Pointer m_MitkAmplitudeImageNode; ///< DataNode holding the amplitude image of the ToF camera as set by Initialize()
     mitk::DataNode::Pointer m_MitkIntensityImageNode; ///< DataNode holding the intensity image of the ToF camera as set by Initialize()
     mitk::DataNode::Pointer m_MitkSurfaceNode; ///< DataNode holding the surface
 
     vtkColorTransferFunction* m_Widget1ColorTransferFunction; ///< vtkColorTransferFunction of widget 1 (distance) that can be used to define a TransferFunctionProperty
     vtkColorTransferFunction* m_Widget2ColorTransferFunction; ///< vtkColorTransferFunction of widget 2 (amplitude) that can be used to define a TransferFunctionProperty
     vtkColorTransferFunction* m_Widget3ColorTransferFunction; ///< vtkColorTransferFunction of widget 3 (intensity) that can be used to define a TransferFunctionProperty
 
     int m_Widget1TransferFunctionType; ///< member holding the type of the transfer function applied to the image shown in widget 1 (distance image): 0 = gray scale, 1 = color
     int m_Widget2TransferFunctionType; ///< member holding the type of the transfer function applied to the image shown in widget 2 (amplitude image): 0 = gray scale, 1 = color
     int m_Widget3TransferFunctionType; ///< member holding the type of the transfer function applied to the image shown in widget 3 (intensity image): 0 = gray scale, 1 = color
 
   private:
 
     /**
      * @brief UpdateSurfaceProperty Private helper method to update the surface property color transfer function.
      */
     void UpdateSurfaceProperty();
 
 
     /*!
     \brief Reset the color transfer function to the given type and range
     \param colorTransferFunction vtkColorTransferfunction to be resetted
     \param type type of the transfer function: 0 = gray scale, 1 = color
     \param min minimal value to be set to the transfer function
     \param max maximal value to be set to the transfer function
     */
     void ResetTransferFunction(vtkColorTransferFunction* colorTransferFunction, int type, double min, double max);
     /*!
     \brief Reset the color transfer function for the given widget
     \param widget 0: axial, 1: coronal, 2: sagittal
     \param type: type of the transfer function: 0 = gray scale, 1 = color
     */
     void ReinitTransferFunction(int widget, int type);
 };
 
 #endif // _QMITKTOFVISUALISATIONSETTINGSWIDGET_H_INCLUDED
diff --git a/Plugins/PluginList.cmake b/Plugins/PluginList.cmake
index ac518360a0..793c9f1210 100644
--- a/Plugins/PluginList.cmake
+++ b/Plugins/PluginList.cmake
@@ -1,90 +1,89 @@
 
 # Plug-ins must be ordered according to their dependencies
 
 set(MITK_PLUGINS
 
   org.blueberry.core.runtime:ON
   org.blueberry.core.expressions:OFF
   org.blueberry.core.commands:OFF
   org.blueberry.core.jobs:OFF
   org.blueberry.ui.qt:OFF
   org.blueberry.ui.qt.help:ON
   org.blueberry.ui.qt.log:ON
   org.blueberry.ui.qt.objectinspector:OFF
   org.mitk.core.services:ON
   org.mitk.gui.common:ON
   org.mitk.planarfigure:ON
   org.mitk.core.ext:OFF
   org.mitk.core.jobs:OFF
   org.mitk.gui.qt.application:ON
   org.mitk.gui.qt.ext:OFF
   org.mitk.gui.qt.extapplication:OFF
   org.mitk.gui.qt.mitkworkbench.intro:OFF
   org.mitk.gui.qt.common:ON
   org.mitk.gui.qt.stdmultiwidgeteditor:ON
   org.mitk.gui.qt.mxnmultiwidgeteditor:OFF
-  org.mitk.gui.qt.common.legacy:OFF
   org.mitk.gui.qt.cmdlinemodules:OFF
   org.mitk.gui.qt.chartExample:OFF
   org.mitk.gui.qt.datamanager:ON
   org.mitk.gui.qt.datamanagerlight:OFF
   org.mitk.gui.qt.datastorageviewertest:OFF
   org.mitk.gui.qt.properties:ON
   org.mitk.gui.qt.basicimageprocessing:OFF
   org.mitk.gui.qt.dicombrowser:OFF
   org.mitk.gui.qt.dicominspector:OFF
   org.mitk.gui.qt.dosevisualization:OFF
   org.mitk.gui.qt.geometrytools:OFF
   org.mitk.gui.qt.igtexamples:OFF
   org.mitk.gui.qt.igttracking:OFF
   org.mitk.gui.qt.openigtlink:OFF
   org.mitk.gui.qt.imagecropper:OFF
   org.mitk.gui.qt.imagenavigator:ON
   org.mitk.gui.qt.viewnavigator:OFF
   org.mitk.gui.qt.materialeditor:OFF
   org.mitk.gui.qt.measurementtoolbox:OFF
   org.mitk.gui.qt.moviemaker:OFF
   org.mitk.gui.qt.pointsetinteraction:OFF
   org.mitk.gui.qt.pointsetinteractionmultispectrum:OFF
   org.mitk.gui.qt.python:OFF
   org.mitk.gui.qt.remeshing:OFF
   org.mitk.gui.qt.segmentation:OFF
   org.mitk.gui.qt.deformableclippingplane:OFF
   org.mitk.gui.qt.aicpregistration:OFF
   org.mitk.gui.qt.renderwindowmanager:OFF
   org.mitk.gui.qt.semanticrelations:OFF
   org.mitk.gui.qt.toftutorial:OFF
   org.mitk.gui.qt.tofutil:OFF
   org.mitk.gui.qt.tubegraph:OFF
   org.mitk.gui.qt.ugvisualization:OFF
   org.mitk.gui.qt.ultrasound:OFF
   org.mitk.gui.qt.volumevisualization:OFF
   org.mitk.gui.qt.eventrecorder:OFF
   org.mitk.gui.qt.xnat:OFF
   org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation:OFF
   org.mitk.gui.qt.classificationsegmentation:OFF
   org.mitk.gui.qt.overlaymanager:OFF
   org.mitk.gui.qt.igt.app.hummelprotocolmeasurements:OFF
   org.mitk.gui.qt.multilabelsegmentation:OFF
   org.mitk.matchpoint.core.helper:OFF
   org.mitk.gui.qt.matchpoint.algorithm.browser:OFF
   org.mitk.gui.qt.matchpoint.algorithm.control:OFF
   org.mitk.gui.qt.matchpoint.mapper:OFF
   org.mitk.gui.qt.matchpoint.framereg:OFF
   org.mitk.gui.qt.matchpoint.visualizer:OFF
   org.mitk.gui.qt.matchpoint.evaluator:OFF
   org.mitk.gui.qt.matchpoint.manipulator:OFF
   org.mitk.gui.qt.preprocessing.resampling:OFF
   org.mitk.gui.qt.radiomics:OFF
   org.mitk.gui.qt.cest:OFF
   org.mitk.gui.qt.fit.demo:OFF
   org.mitk.gui.qt.fit.inspector:OFF
   org.mitk.gui.qt.fit.genericfitting:OFF
   org.mitk.gui.qt.pharmacokinetics.mri:OFF
   org.mitk.gui.qt.pharmacokinetics.pet:OFF
   org.mitk.gui.qt.pharmacokinetics.simulation:OFF
   org.mitk.gui.qt.pharmacokinetics.curvedescriptor:OFF
   org.mitk.gui.qt.pharmacokinetics.concentration.mri:OFF
   org.mitk.gui.qt.flowapplication:OFF
   org.mitk.gui.qt.flow.segmentation:OFF
 )
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
index decbec0004..c706326752 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkAbstractDataNodeAction.cpp
@@ -1,120 +1,117 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkAbstractDataNodeAction.h>
 
 #include "mitkIRenderWindowPart.h"
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // berry
 #include <berryIWorkbenchPage.h>
 
 QList<mitk::DataNode::Pointer> AbstractDataNodeAction::GetSelectedNodes(berry::IWorkbenchPartSite::Pointer workbenchPartSite)
 {
   QList<mitk::DataNode::Pointer> selectedNodes;
   if (workbenchPartSite.IsNull())
   {
     return selectedNodes;
   }
 
   berry::ISelection::ConstPointer selection = workbenchPartSite->GetWorkbenchWindow()->GetSelectionService()->GetSelection();
   mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
   if (currentSelection.IsNull() || currentSelection->IsEmpty())
   {
     return selectedNodes;
   }
 
   selectedNodes = QList<mitk::DataNode::Pointer>::fromStdList(currentSelection->GetSelectedDataNodes());
   return selectedNodes;
 }
 
 QmitkAbstractDataNodeAction::QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer workbenchPartSite)
 {
   m_WorkbenchPartSite = workbenchPartSite;
 }
 
 QmitkAbstractDataNodeAction::QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite* workbenchPartSite)
 {
   m_WorkbenchPartSite = berry::IWorkbenchPartSite::Pointer(workbenchPartSite);
 }
 
 void QmitkAbstractDataNodeAction::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage != dataStorage)
   {
     // set the new data storage
     m_DataStorage = dataStorage;
   }
 }
 
 void QmitkAbstractDataNodeAction::SetSelectedNodes(const QList<mitk::DataNode::Pointer>& selectedNodes)
 {
   m_SelectedNodes = selectedNodes;
   // use the first selected node to initialize the data node actions
   InitializeWithDataNode(m_SelectedNodes.front());
 }
 
 void QmitkAbstractDataNodeAction::SetBaseRenderer(mitk::BaseRenderer* baseRenderer)
 {
   if (m_BaseRenderer != baseRenderer)
   {
     // set the new base renderer
     m_BaseRenderer = baseRenderer;
   }
 }
 
 mitk::BaseRenderer::Pointer QmitkAbstractDataNodeAction::GetBaseRenderer()
 {
-  mitk::BaseRenderer::Pointer baseRenderer;
-  if (!m_BaseRenderer.IsExpired())
-  {
-    baseRenderer = m_BaseRenderer.Lock();
-  }
-  return baseRenderer;
+  return m_BaseRenderer.Lock();
 }
 
 QList<mitk::DataNode::Pointer> QmitkAbstractDataNodeAction::GetSelectedNodes() const
 {
   if (!m_SelectedNodes.isEmpty())
   {
     return m_SelectedNodes;
   }
 
-  if (m_WorkbenchPartSite.Expired())
+  auto workbenchPartSite = m_WorkbenchPartSite.Lock();
+
+  if (workbenchPartSite.IsNull())
   {
     // return empty list of selected nodes
     return m_SelectedNodes;
   }
 
   // retrieve selection from the workbench selection service
-  return AbstractDataNodeAction::GetSelectedNodes(m_WorkbenchPartSite.Lock());
+  return AbstractDataNodeAction::GetSelectedNodes(workbenchPartSite);
 }
 
 mitk::DataNode::Pointer QmitkAbstractDataNodeAction::GetSelectedNode() const
 {
   QList<mitk::DataNode::Pointer> selectedNodes = GetSelectedNodes();
   if (selectedNodes.empty())
   {
     return nullptr;
   }
 
   // no batch action; should only be called with a single node
   mitk::DataNode::Pointer dataNode = selectedNodes.front();
   if (nullptr == dataNode)
   {
     return nullptr;
   }
 
   return dataNode;
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
index a8a7e00ce6..9c3e7eea21 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeContextMenu.cpp
@@ -1,480 +1,483 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkDataNodeContextMenu.h>
 
 #include <QmitkCustomVariants.h>
 #include <QmitkFileSaveAction.h>
 #include <QmitkNodeDescriptorManager.h>
 
 #include <mitkDataNodeSelection.h>
 #include <mitkIContextMenuAction.h>
 
 #include <berryAbstractUICTKPlugin.h>
 #include <berryIContributor.h>
 #include <berryIExtensionRegistry.h>
 #include <berryISelectionService.h>
 #include <berryPlatform.h>
 
 QmitkDataNodeContextMenu::QmitkDataNodeContextMenu(berry::IWorkbenchPartSite::Pointer workbenchPartSite, QWidget* parent)
   : QMenu(parent),
     m_Parent(parent),
     m_WorkbenchPartSite(workbenchPartSite)
 {
   this->InitNodeDescriptors();
   this->InitDefaultActions();
   this->InitExtensionPointActions();
 }
 
 QmitkDataNodeContextMenu::~QmitkDataNodeContextMenu()
 {
   for (auto& descriptorActionPair : m_DescriptorActionList)
     descriptorActionPair.first->RemoveAction(descriptorActionPair.second);
 }
 
 void QmitkDataNodeContextMenu::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   m_DataStorage = dataStorage;
 
   for (auto& descriptorActionPair : m_DescriptorActionList)
   {
     auto dataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(descriptorActionPair.second);
 
     if (nullptr != dataNodeAction)
       dataNodeAction->SetDataStorage(dataStorage);
   }  
 }
 
 void QmitkDataNodeContextMenu::SetBaseRenderer(mitk::BaseRenderer* baseRenderer)
 {
   m_BaseRenderer = baseRenderer;
 
   for (auto& descriptorActionPair : m_DescriptorActionList)
   {
     auto dataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(descriptorActionPair.second);
 
     if (nullptr != dataNodeAction)
       dataNodeAction->SetBaseRenderer(baseRenderer);
   }
 }
 
 void QmitkDataNodeContextMenu::SetSurfaceDecimation(bool surfaceDecimation)
 {
   m_SurfaceDecimation = surfaceDecimation;
 }
 
 void QmitkDataNodeContextMenu::SetSelectedNodes(const QList<mitk::DataNode::Pointer>& selectedNodes)
 {
   m_SelectedNodes = selectedNodes;
 }
 
 void QmitkDataNodeContextMenu::InitNodeDescriptors()
 {
   auto nodeDescriptorManager = QmitkNodeDescriptorManager::GetInstance();
 
   m_UnknownDataNodeDescriptor = nodeDescriptorManager->GetUnknownDataNodeDescriptor();
   m_ImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("Image");
   m_MultiComponentImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("MultiComponentImage");
   m_DiffusionImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("DiffusionImage");
   m_FiberBundleDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("FiberBundle");
   m_PeakImageDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("PeakImage");
   m_SegmentDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("Segment");
   m_SurfaceDataNodeDescriptor = nodeDescriptorManager->GetDescriptor("Surface");
   m_PointSetNodeDescriptor = nodeDescriptorManager->GetDescriptor("PointSet");
   m_PlanarLineNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarLine");
   m_PlanarCircleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarCircle");
   m_PlanarEllipseNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarEllipse");
   m_PlanarAngleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarAngle");
   m_PlanarFourPointAngleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarFourPointAngle");
   m_PlanarRectangleNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarRectangle");
   m_PlanarPolygonNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarPolygon");
   m_PlanarPathNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarPath");
   m_PlanarDoubleEllipseNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarDoubleEllipse");
   m_PlanarBezierCurveNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarBezierCurve");
   m_PlanarSubdivisionPolygonNodeDescriptor = nodeDescriptorManager->GetDescriptor("PlanarSubdivisionPolygon");
 }
 
 void QmitkDataNodeContextMenu::InitDefaultActions()
 {
   auto workbenchPartSite = m_WorkbenchPartSite.Lock();
 
   m_GlobalReinitAction = new QmitkDataNodeGlobalReinitAction(m_Parent, workbenchPartSite);
   m_GlobalReinitAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_GlobalReinitAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_GlobalReinitAction));
 
   m_ReinitAction = new QmitkDataNodeReinitAction(m_Parent, workbenchPartSite);
   m_ReinitAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ReinitAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ReinitAction));
 
   QAction* saveAction = new QmitkFileSaveAction(QIcon(":/org.mitk.gui.qt.datamanager/Save_48.png"), workbenchPartSite->GetWorkbenchWindow());
   m_UnknownDataNodeDescriptor->AddAction(saveAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, saveAction));
 
   m_RemoveAction = new QmitkDataNodeRemoveAction(m_Parent, workbenchPartSite);
   m_RemoveAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/Remove_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_RemoveAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_RemoveAction));
 
   m_ShowSelectedNodesAction = new QmitkDataNodeShowSelectedNodesAction(m_Parent, workbenchPartSite);
   m_RemoveAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/ShowSelectedNode_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ShowSelectedNodesAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ShowSelectedNodesAction));
 
   m_ToggleVisibilityAction = new QmitkDataNodeToggleVisibilityAction(m_Parent, workbenchPartSite);
   m_ToggleVisibilityAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/InvertShowSelectedNode_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ToggleVisibilityAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ToggleVisibilityAction));
 
   m_ShowDetailsAction = new QmitkDataNodeShowDetailsAction(m_Parent, workbenchPartSite);
   m_ShowDetailsAction->setIcon(QIcon(":/org.mitk.gui.qt.datamanager/ShowDataInfo_48.png"));
   m_UnknownDataNodeDescriptor->AddAction(m_ShowDetailsAction, true);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_ShowDetailsAction));
 
   m_OpacityAction = new QmitkDataNodeOpacityAction(m_Parent, workbenchPartSite);
   m_UnknownDataNodeDescriptor->AddAction(m_OpacityAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_UnknownDataNodeDescriptor, m_OpacityAction));
 
   m_ColorAction = new QmitkDataNodeColorAction(m_Parent, workbenchPartSite);
   this->AddColorAction(m_ColorAction);
 
   m_ColormapAction = new QmitkDataNodeColorMapAction(m_Parent, workbenchPartSite);
   m_ImageDataNodeDescriptor->AddAction(m_ColormapAction);
   m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, m_ColormapAction));
 
   if (nullptr != m_DiffusionImageDataNodeDescriptor)
   {
     m_DiffusionImageDataNodeDescriptor->AddAction(m_ColormapAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_ColormapAction));
   }
 
   m_ComponentAction = new QmitkDataNodeComponentAction(m_Parent, workbenchPartSite);
   m_MultiComponentImageDataNodeDescriptor->AddAction(m_ComponentAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_MultiComponentImageDataNodeDescriptor, m_ComponentAction));
 
   if (nullptr != m_DiffusionImageDataNodeDescriptor)
   {
     m_DiffusionImageDataNodeDescriptor->AddAction(m_ComponentAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_ComponentAction));
   }
 
   m_TextureInterpolationAction = new QmitkDataNodeTextureInterpolationAction(m_Parent, workbenchPartSite);
   m_ImageDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, m_TextureInterpolationAction));
 
   if (nullptr != m_DiffusionImageDataNodeDescriptor)
   {
     m_DiffusionImageDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, m_TextureInterpolationAction));
   }
 
   if (nullptr != m_SegmentDataNodeDescriptor)
   {
     m_SegmentDataNodeDescriptor->AddAction(m_TextureInterpolationAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_SegmentDataNodeDescriptor, m_TextureInterpolationAction));
   }
 
   m_SurfaceRepresentationAction = new QmitkDataNodeSurfaceRepresentationAction(m_Parent, workbenchPartSite);
   m_SurfaceDataNodeDescriptor->AddAction(m_SurfaceRepresentationAction, false);
   m_DescriptorActionList.push_back(std::make_pair(m_SurfaceDataNodeDescriptor, m_SurfaceRepresentationAction));
 }
 
 void QmitkDataNodeContextMenu::InitExtensionPointActions()
 {
   auto extensionPointService = berry::Platform::GetExtensionRegistry();
   auto customMenuConfigs = extensionPointService->GetConfigurationElementsFor("org.mitk.gui.qt.datamanager.contextMenuActions");
 
   DescriptorActionListType descriptorActionList;
   m_ConfigElements.clear();
 
   for (const auto& customMenuConfig : qAsConst(customMenuConfigs))
   {
     auto descriptorName = customMenuConfig->GetAttribute("nodeDescriptorName");
     auto actionLabel = customMenuConfig->GetAttribute("label");
     auto actionClass = customMenuConfig->GetAttribute("class");
 
     if (descriptorName.isEmpty() || actionLabel.isEmpty() || actionClass.isEmpty())
       continue;
 
     auto descriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(descriptorName);
 
     if (nullptr == descriptor)
     {
       MITK_WARN << "Cannot add action \"" << actionLabel << "\" to non-existent descriptor \"" << descriptorName << "\".";
       continue;
     }
 
     QAction* action = nullptr;
     auto actionIcon = customMenuConfig->GetAttribute("icon");
 
     if (!actionIcon.isEmpty())
     {
       QIcon icon = !QFile::exists(actionIcon)
         ? berry::AbstractUICTKPlugin::ImageDescriptorFromPlugin(customMenuConfig->GetContributor()->GetName(), actionIcon)
         : QIcon(actionIcon);
 
       action = new QAction(icon, actionLabel, m_Parent);
     }
     else
     {
       action = new QAction(actionLabel, m_Parent);
     }
 
     if (nullptr != action)
     {
       // See T26938. We do not know why but without the lambda function indirection, the
       // connection is lost after the content menu was shown for the first time.
       connect(action, &QAction::triggered, [action, this]()
       {
         this->OnExtensionPointActionTriggered(action);
       });
 
       m_ConfigElements[action] = customMenuConfig;
       descriptorActionList.push_back(std::make_pair(descriptor, action));
     }
   }
 
   this->AddDescriptorActionList(descriptorActionList);
 }
 
 void QmitkDataNodeContextMenu::InitServiceActions()
 {
 }
 
 void QmitkDataNodeContextMenu::OnContextMenuRequested(const QPoint& /*pos*/)
 {
-  if (m_WorkbenchPartSite.Expired())
+  auto workbenchPartSite = m_WorkbenchPartSite.Lock();
+
+  if (workbenchPartSite.IsNull())
     return;
 
-  auto selection = m_WorkbenchPartSite.Lock()->GetWorkbenchWindow()->GetSelectionService()->GetSelection()
+  auto selection = workbenchPartSite->GetWorkbenchWindow()->GetSelectionService()->GetSelection()
     .Cast<const mitk::DataNodeSelection>();
 
   if (selection.IsNull() || selection->IsEmpty())
     return;
 
   m_SelectedNodes = QList<mitk::DataNode::Pointer>::fromStdList(selection->GetSelectedDataNodes());
 
   if (!m_SelectedNodes.isEmpty())
   {
     this->clear();
 
     auto actions = m_SelectedNodes.size() == 1
       ? this->GetActions(m_SelectedNodes.front())
       : this->GetActions(m_SelectedNodes);
 
     for (auto& action : actions)
     {
       auto dataNodeAction = dynamic_cast<QmitkAbstractDataNodeAction*>(action);
 
       if (nullptr != dataNodeAction)
         dataNodeAction->SetSelectedNodes(m_SelectedNodes);
     }
 
     this->addActions(actions);
     this->popup(QCursor::pos());
   }
 }
 
 void QmitkDataNodeContextMenu::OnExtensionPointActionTriggered(QAction* action)
 {
   auto configElementIter = m_ConfigElements.find(action);
 
   if (m_ConfigElements.end() == configElementIter)
   {
     MITK_WARN << "Associated configuration element for action \"" << action->text() << "\" not found.";
     return;
   }
 
   auto configElement = configElementIter->second;
   auto contextMenuAction = configElement->CreateExecutableExtension<mitk::IContextMenuAction>("class");
+  auto dataStorage = m_DataStorage.Lock();
 
-  if (!m_DataStorage.IsExpired())
-    contextMenuAction->SetDataStorage(m_DataStorage.Lock());
+  if (dataStorage.IsNotNull())
+    contextMenuAction->SetDataStorage(dataStorage);
 
   if ("QmitkCreatePolygonModelAction" == configElement->GetAttribute("class"))
   {
     contextMenuAction->SetSmoothed("true" == configElement->GetAttribute("smoothed"));
     contextMenuAction->SetDecimated(m_SurfaceDecimation);
   }
 
   contextMenuAction->Run(m_SelectedNodes);
 }
 
 void QmitkDataNodeContextMenu::AddColorAction(QWidgetAction* colorAction)
 {
   if (nullptr != m_ImageDataNodeDescriptor)
   {
     m_ImageDataNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_ImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_MultiComponentImageDataNodeDescriptor)
   {
     m_MultiComponentImageDataNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_MultiComponentImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_DiffusionImageDataNodeDescriptor)
   {
     m_DiffusionImageDataNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_DiffusionImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_FiberBundleDataNodeDescriptor)
   {
     m_FiberBundleDataNodeDescriptor->AddAction(colorAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_FiberBundleDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PeakImageDataNodeDescriptor)
   {
     m_PeakImageDataNodeDescriptor->AddAction(colorAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_PeakImageDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_SegmentDataNodeDescriptor)
   {
     m_SegmentDataNodeDescriptor->AddAction(colorAction, false);
     m_DescriptorActionList.push_back(std::make_pair(m_SegmentDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_SurfaceDataNodeDescriptor)
   {
     m_SurfaceDataNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_SurfaceDataNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PointSetNodeDescriptor)
   {
     m_PointSetNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PointSetNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarLineNodeDescriptor)
   {
     m_PlanarLineNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarLineNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarCircleNodeDescriptor)
   {
     m_PlanarCircleNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarCircleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarEllipseNodeDescriptor)
   {
     m_PlanarEllipseNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarEllipseNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarAngleNodeDescriptor)
   {
     m_PlanarAngleNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarAngleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarFourPointAngleNodeDescriptor)
   {
     m_PlanarFourPointAngleNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarFourPointAngleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarRectangleNodeDescriptor)
   {
     m_PlanarRectangleNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarRectangleNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarPolygonNodeDescriptor)
   {
     m_PlanarPolygonNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarPolygonNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarPathNodeDescriptor)
   {
     m_PlanarPathNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarPathNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarDoubleEllipseNodeDescriptor)
   {
     m_PlanarDoubleEllipseNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarDoubleEllipseNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarBezierCurveNodeDescriptor)
   {
     m_PlanarBezierCurveNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarBezierCurveNodeDescriptor, colorAction));
   }
 
   if (nullptr != m_PlanarSubdivisionPolygonNodeDescriptor)
   {
     m_PlanarSubdivisionPolygonNodeDescriptor->AddAction(colorAction, true);
     m_DescriptorActionList.push_back(std::make_pair(m_PlanarSubdivisionPolygonNodeDescriptor, colorAction));
   }
 }
 
 void QmitkDataNodeContextMenu::AddDescriptorActionList(DescriptorActionListType& descriptorActionList)
 {
   using ListItem = std::pair<QmitkNodeDescriptor*, QAction*>;
 
   std::sort(descriptorActionList.begin(), descriptorActionList.end(), [](const ListItem& left, const ListItem& right) -> bool
   {
     return left.second->text() < right.second->text();
   });
 
   for (auto& descriptorActionPair : descriptorActionList)
   {
     descriptorActionPair.first->AddAction(descriptorActionPair.second);
     m_DescriptorActionList.push_back(descriptorActionPair);
   }
 }
 
 QList<QAction*> QmitkDataNodeContextMenu::GetActions(const mitk::DataNode* node)
 {
   QList<QAction*> actions;
 
   for(const auto& descriptorActionPair : m_DescriptorActionList)
   {
     if (descriptorActionPair.first->CheckNode(node) || "Unknown" == descriptorActionPair.first->GetNameOfClass())
       actions.append(descriptorActionPair.second);
   }
 
   return actions;
 }
 
 QList<QAction*> QmitkDataNodeContextMenu::GetActions(const QList<mitk::DataNode::Pointer>& nodes)
 {
   QList<QAction*> actions;
 
   for (const auto& descriptorActionPair : m_DescriptorActionList)
   {
     for (const auto& node : nodes)
     {
       if (descriptorActionPair.first->CheckNode(node) || "Unknown" == descriptorActionPair.first->GetNameOfClass())
       {
         auto batchActions = descriptorActionPair.first->GetBatchActions();
 
         if (std::find(batchActions.begin(), batchActions.end(), descriptorActionPair.second) != batchActions.end())
           actions.append(descriptorActionPair.second);
 
         break;
       }
     }
   }
 
   return actions;
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeGlobalReinitAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeGlobalReinitAction.cpp
index 1d86c3658a..7529cc5fbc 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeGlobalReinitAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeGlobalReinitAction.cpp
@@ -1,77 +1,81 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkDataNodeGlobalReinitAction.h>
 
 // mitk core
 #include <mitkRenderingManager.h>
 
 // mitk gui common plugin
 #include <mitkWorkbenchUtil.h>
 
 const QString QmitkDataNodeGlobalReinitAction::ACTION_ID = "org.mitk.gui.qt.application.globalreinitaction";
 
 // namespace that contains the concrete action
 namespace GlobalReinitAction
 {
   void Run(berry::IWorkbenchPartSite::Pointer workbenchPartSite, mitk::DataStorage::Pointer dataStorage)
   {
     auto renderWindow = mitk::WorkbenchUtil::GetRenderWindowPart(workbenchPartSite->GetPage(), mitk::WorkbenchUtil::NONE);
     if (nullptr == renderWindow)
     {
       renderWindow = mitk::WorkbenchUtil::OpenRenderWindowPart(workbenchPartSite->GetPage(), false);
       if (nullptr == renderWindow)
       {
         // no render window available
         return;
       }
     }
 
     mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
   }
 }
 
 QmitkDataNodeGlobalReinitAction::QmitkDataNodeGlobalReinitAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchPartSite)
 {
   setText(tr("Global Reinit"));
   InitializeAction();
 }
 
 QmitkDataNodeGlobalReinitAction::QmitkDataNodeGlobalReinitAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Global Reinit"));
   InitializeAction();
 }
 
 void QmitkDataNodeGlobalReinitAction::InitializeAction()
 {
   connect(this, &QmitkDataNodeGlobalReinitAction::triggered, this, &QmitkDataNodeGlobalReinitAction::OnActionTriggered);
 }
 
 void QmitkDataNodeGlobalReinitAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_WorkbenchPartSite.Expired())
+  auto workbenchPartSite = m_WorkbenchPartSite.Lock();
+
+  if (workbenchPartSite.IsNull())
   {
     return;
   }
 
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  GlobalReinitAction::Run(m_WorkbenchPartSite.Lock(), m_DataStorage.Lock());
+  GlobalReinitAction::Run(workbenchPartSite, dataStorage);
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeReinitAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeReinitAction.cpp
index 1a62a732dc..622d38362f 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeReinitAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeReinitAction.cpp
@@ -1,133 +1,137 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkDataNodeReinitAction.h>
 
 // mitk core
 #include <mitkImage.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkRenderingManager.h>
 
 // mitk gui common plugin
 #include <mitkWorkbenchUtil.h>
 
 // namespace that contains the concrete action
 namespace ReinitAction
 {
   void Run(berry::IWorkbenchPartSite::Pointer workbenchPartSite, mitk::DataStorage::Pointer dataStorage, const QList<mitk::DataNode::Pointer>& selectedNodes /*= QList<mitk::DataNode::Pointer>()*/, mitk::BaseRenderer* baseRenderer /*= nullptr*/)
   {
     if (selectedNodes.empty())
     {
       return;
     }
 
     if (workbenchPartSite.IsNotNull())
     {
       auto renderWindow = mitk::WorkbenchUtil::GetRenderWindowPart(workbenchPartSite->GetPage(), mitk::WorkbenchUtil::NONE);
       if (nullptr == renderWindow)
       {
         renderWindow = mitk::WorkbenchUtil::OpenRenderWindowPart(workbenchPartSite->GetPage(), false);
         if (nullptr == renderWindow)
         {
           // no render window available
           return;
         }
       }
     }
 
 
     auto boundingBoxPredicate = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false), baseRenderer));
 
     mitk::DataStorage::SetOfObjects::Pointer nodes = mitk::DataStorage::SetOfObjects::New();
     for (const auto& dataNode : selectedNodes)
     {
       if (boundingBoxPredicate->CheckNode(dataNode))
       {
         nodes->InsertElement(nodes->Size(), dataNode);
       }
     }
 
     if (nodes->empty())
     {
       return;
     }
 
     if (1 == nodes->Size()) // Special case: If exactly one ...
     {
       auto image = dynamic_cast<mitk::Image*>(nodes->ElementAt(0)->GetData());
 
       if (nullptr != image) // ... image is selected, reinit is expected to rectify askew images.
       {
         if (nullptr == baseRenderer)
         {
           mitk::RenderingManager::GetInstance()->InitializeViews(image->GetTimeGeometry());
         }
         else
         {
           mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), image->GetTimeGeometry());
         }
         return;
       }
     }
 
     auto boundingGeometry = dataStorage->ComputeBoundingGeometry3D(nodes, "visible", baseRenderer);
     if (nullptr == baseRenderer)
     {
       mitk::RenderingManager::GetInstance()->InitializeViews(boundingGeometry);
     }
     else
     {
       mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), boundingGeometry);
     }
   }
 }
 
 QmitkDataNodeReinitAction::QmitkDataNodeReinitAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Reinit"));
   InitializeAction();
 }
 
 QmitkDataNodeReinitAction::QmitkDataNodeReinitAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Reinit"));
   InitializeAction();
 }
 
 void QmitkDataNodeReinitAction::InitializeAction()
 {
   connect(this, &QmitkDataNodeReinitAction::triggered, this, &QmitkDataNodeReinitAction::OnActionTriggered);
 }
 
 void QmitkDataNodeReinitAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_WorkbenchPartSite.Expired())
+  auto workbenchPartSite = m_WorkbenchPartSite.Lock();
+
+  if (workbenchPartSite.IsNull())
   {
     return;
   }
 
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
   mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   auto selectedNodes = GetSelectedNodes();
-  ReinitAction::Run(m_WorkbenchPartSite.Lock(), m_DataStorage.Lock(), selectedNodes, baseRenderer);
+  ReinitAction::Run(workbenchPartSite, dataStorage, selectedNodes, baseRenderer);
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeRemoveAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeRemoveAction.cpp
index bd7020d5d1..d27dc9c17a 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeRemoveAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeRemoveAction.cpp
@@ -1,114 +1,118 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkDataNodeRemoveAction.h>
 #include <QmitkDataNodeGlobalReinitAction.h>
 
 // qt
 #include <QMessageBox>
 
 // berry
 #include <berryIPreferences.h>
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 namespace RemoveAction
 {
   void Run(berry::IWorkbenchPartSite::Pointer workbenchPartSite, mitk::DataStorage::Pointer dataStorage, const QList<mitk::DataNode::Pointer>& selectedNodes, QWidget* parent /* = nullptr*/)
   {
     if (selectedNodes.empty())
     {
       return;
     }
 
     QString question("Do you really want to remove ");
     for (auto& dataNode : selectedNodes)
     {
       if (nullptr == dataNode)
       {
         continue;
       }
 
       question.append(QString::fromStdString(dataNode->GetName()));
       question.append(", ");
     }
 
     // remove the last two characters = ", "
     question = question.remove(question.size() - 2, 2);
     question.append(" from data storage?");
 
     QMessageBox::StandardButton answerButton =
       QMessageBox::question(parent, "DataManager", question, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
     if (answerButton == QMessageBox::Yes)
     {
       for (auto& dataNode : selectedNodes)
       {
         if (nullptr == dataNode)
         {
           continue;
         }
 
         dataStorage->Remove(dataNode);
       }
 
       berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
       berry::IPreferences::Pointer preferencesNode =
         prefService->GetSystemPreferences()->Node(QmitkDataNodeGlobalReinitAction::ACTION_ID);
 
       bool globalReinit = preferencesNode->GetBool("Call global reinit if node is deleted", true);
       if (globalReinit)
       {
         GlobalReinitAction::Run(workbenchPartSite, dataStorage);
       }
     }
   }
 }
 
 QmitkDataNodeRemoveAction::QmitkDataNodeRemoveAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Remove"));
   m_Parent = parent;
   InitializeAction();
 }
 
 QmitkDataNodeRemoveAction::QmitkDataNodeRemoveAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Remove"));
   m_Parent = parent;
   InitializeAction();
 }
 
 void QmitkDataNodeRemoveAction::InitializeAction()
 {
   connect(this, &QmitkDataNodeRemoveAction::triggered, this, &QmitkDataNodeRemoveAction::OnActionTriggered);
 }
 
 void QmitkDataNodeRemoveAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_WorkbenchPartSite.Expired())
+  auto workbenchPartSite = m_WorkbenchPartSite.Lock();
+
+  if (workbenchPartSite.IsNull())
   {
     return;
   }
 
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
   auto selectedNodes = GetSelectedNodes();
-  RemoveAction::Run(m_WorkbenchPartSite.Lock(), m_DataStorage.Lock(), selectedNodes, m_Parent);
+  RemoveAction::Run(workbenchPartSite, dataStorage, selectedNodes, m_Parent);
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeShowSelectedNodesAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeShowSelectedNodesAction.cpp
index 368f6d289d..f9a998d19c 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeShowSelectedNodesAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeShowSelectedNodesAction.cpp
@@ -1,71 +1,71 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkDataNodeShowSelectedNodesAction.h>
 #include <mitkNodePredicateFirstLevel.h>
 
 // mitk core
 #include <mitkRenderingManager.h>
 
 QmitkDataNodeShowSelectedNodesAction::QmitkDataNodeShowSelectedNodesAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Show only selected nodes"));
   InitializeAction();
 }
 
 QmitkDataNodeShowSelectedNodesAction::QmitkDataNodeShowSelectedNodesAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Show only selected nodes"));
   InitializeAction();
 }
 
 void QmitkDataNodeShowSelectedNodesAction::InitializeAction()
 {
   connect(this, &QmitkDataNodeShowSelectedNodesAction::triggered, this, &QmitkDataNodeShowSelectedNodesAction::OnActionTriggered);
 }
 
 void QmitkDataNodeShowSelectedNodesAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   auto selectedNodes = GetSelectedNodes();
 
   auto allNodes = dataStorage->GetAll();
 
   for (auto& node : *allNodes)
   {
     if (node.IsNotNull() && node->GetData() != nullptr && strcmp(node->GetData()->GetNameOfClass(), "PlaneGeometryData"))
     {
       node->SetVisibility(selectedNodes.contains(node), baseRenderer);
     }
   }
 
   if (nullptr == baseRenderer)
   {
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else
   {
     mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeToggleVisibilityAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeToggleVisibilityAction.cpp
index c06967fb8e..a3eb2dc0ab 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeToggleVisibilityAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkDataNodeToggleVisibilityAction.cpp
@@ -1,99 +1,103 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <QmitkDataNodeToggleVisibilityAction.h>
 #include <QmitkDataNodeGlobalReinitAction.h>
 
 // mitk core
 #include <mitkRenderingManager.h>
 
 // berry
 #include <berryIPreferences.h>
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 // namespace that contains the concrete action
 namespace ToggleVisibilityAction
 {
   void Run(berry::IWorkbenchPartSite::Pointer workbenchPartSite, mitk::DataStorage::Pointer dataStorage, const QList<mitk::DataNode::Pointer>& selectedNodes /*= QList<mitk::DataNode::Pointer>()*/, mitk::BaseRenderer* baseRenderer /*= nullptr*/)
   {
     bool isVisible;
     for (auto& node : selectedNodes)
     {
       if (node.IsNotNull())
       {
         isVisible = false;
         node->GetBoolProperty("visible", isVisible, baseRenderer);
         node->SetVisibility(!isVisible, baseRenderer);
       }
     }
 
     berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
 
     berry::IPreferences::Pointer preferences = prefService->GetSystemPreferences()->Node(QmitkDataNodeGlobalReinitAction::ACTION_ID);
     bool globalReinit = preferences->GetBool("Call global reinit if node visibility is changed", false);
     if (globalReinit)
     {
       GlobalReinitAction::Run(workbenchPartSite, dataStorage);
     }
     else
     {
       if (nullptr == baseRenderer)
       {
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
       else
       {
         mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
       }
     }
   }
 }
 
 QmitkDataNodeToggleVisibilityAction::QmitkDataNodeToggleVisibilityAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchpartSite)
 {
   setText(tr("Toggle visibility"));
   InitializeAction();
 }
 
 QmitkDataNodeToggleVisibilityAction::QmitkDataNodeToggleVisibilityAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchpartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchpartSite))
 {
   setText(tr("Toggle visibility"));
   InitializeAction();
 }
 
 void QmitkDataNodeToggleVisibilityAction::InitializeAction()
 {
   connect(this, &QmitkDataNodeToggleVisibilityAction::triggered, this, &QmitkDataNodeToggleVisibilityAction::OnActionTriggered);
 }
 
 void QmitkDataNodeToggleVisibilityAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_WorkbenchPartSite.Expired())
+  auto workbenchPartSite = m_WorkbenchPartSite.Lock();
+
+  if (workbenchPartSite.IsNull())
   {
     return;
   }
 
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
   mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
 
   auto dataNodes = GetSelectedNodes();
-  ToggleVisibilityAction::Run(m_WorkbenchPartSite.Lock(), m_DataStorage.Lock(), dataNodes, baseRenderer);
+  ToggleVisibilityAction::Run(workbenchPartSite, dataStorage, dataNodes, baseRenderer);
 }
diff --git a/Plugins/org.mitk.gui.qt.application/src/QmitkFileSaveAction.cpp b/Plugins/org.mitk.gui.qt.application/src/QmitkFileSaveAction.cpp
index 2902c41168..d945baac54 100644
--- a/Plugins/org.mitk.gui.qt.application/src/QmitkFileSaveAction.cpp
+++ b/Plugins/org.mitk.gui.qt.application/src/QmitkFileSaveAction.cpp
@@ -1,273 +1,275 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkFileSaveAction.h"
 
 #include "internal/org_mitk_gui_qt_application_Activator.h"
 
 #include <mitkWorkbenchUtil.h>
 #include <mitkDataNodeSelection.h>
 #include <mitkIDataStorageService.h>
 
 #include <berryISelectionService.h>
 #include <berryINullSelectionListener.h>
 #include <berryIPreferences.h>
 
 #include <QmitkIOUtil.h>
 
 #include <QFileDialog>
 #include <QMessageBox>
 
 namespace
 {
   mitk::DataStorage::Pointer GetDataStorage()
   {
     auto context = mitk::org_mitk_gui_qt_application_Activator::GetContext();
 
     if (nullptr == context)
       return nullptr;
 
     auto dataStorageServiceReference = context->getServiceReference<mitk::IDataStorageService>();
 
     if (!dataStorageServiceReference)
       return nullptr;
 
     auto dataStorageService = context->getService<mitk::IDataStorageService>(dataStorageServiceReference);
 
     if (nullptr == dataStorageService)
       return nullptr;
 
     auto dataStorageReference = dataStorageService->GetDataStorage();
 
     if (dataStorageReference.IsNull())
       return nullptr;
 
     return dataStorageReference->GetDataStorage();
   }
 
   QString GetParentPath(mitk::DataNode::Pointer dataNode)
   {
     if (dataNode.IsNull())
       return "";
 
     auto dataStorage = GetDataStorage();
 
     if (dataStorage.IsNull())
       return "";
 
     auto sources = dataStorage->GetSources(dataNode);
 
     if (sources.IsNull() || sources->empty())
       return "";
 
     const auto &parentNode = sources->front();
 
     if (parentNode.IsNull())
       return "";
 
     auto data = parentNode->GetData();
 
     if (nullptr != data)
     {
       auto pathProperty = data->GetConstProperty("path");
 
       if (pathProperty.IsNotNull())
         return QFileInfo(QString::fromStdString(pathProperty->GetValueAsString())).canonicalPath();
     }
 
     return GetParentPath(parentNode);
   }
 }
 
 class QmitkFileSaveActionPrivate
 {
 private:
 
   void HandleSelectionChanged(const berry::IWorkbenchPart::Pointer& /*part*/,
                               const berry::ISelection::ConstPointer& selection)
   {
     this->SetEnabled(selection);
   }
 
   QScopedPointer<berry::ISelectionListener> m_SelectionListener;
 
 public:
 
   QmitkFileSaveActionPrivate()
     : m_SelectionListener(new berry::NullSelectionChangedAdapter<QmitkFileSaveActionPrivate>(
                             this, &QmitkFileSaveActionPrivate::HandleSelectionChanged))
   {
   }
 
   ~QmitkFileSaveActionPrivate()
   {
-    if (!m_Window.Expired())
+    auto window = m_Window.Lock();
+
+    if (window.IsNotNull())
     {
-      m_Window.Lock()->GetSelectionService()->RemoveSelectionListener(m_SelectionListener.data());
+      window->GetSelectionService()->RemoveSelectionListener(m_SelectionListener.data());
     }
   }
 
   void Init(berry::IWorkbenchWindow* window, QAction* action)
   {
     m_Window = berry::IWorkbenchWindow::Pointer(window);
     m_Action = action;
 
     m_Action->setText("&Save...");
     m_Action->setToolTip("Save data objects (images, surfaces,...)");
 
     berry::ISelectionService* selectionService = m_Window.Lock()->GetSelectionService();
     SetEnabled(selectionService->GetSelection());
 
     selectionService->AddSelectionListener(m_SelectionListener.data());
 
     QObject::connect(m_Action, SIGNAL(triggered(bool)), m_Action, SLOT(Run()));
   }
 
   berry::IPreferences::Pointer GetPreferences() const
   {
     berry::IPreferencesService* prefService = mitk::PluginActivator::GetInstance()->GetPreferencesService();
     if (prefService != nullptr)
     {
       return prefService->GetSystemPreferences()->Node("/General");
     }
     return berry::IPreferences::Pointer(nullptr);
   }
 
   QString GetLastFileSavePath() const
   {
     berry::IPreferences::Pointer prefs = GetPreferences();
     if (prefs.IsNotNull())
     {
       return prefs->Get("LastFileSavePath", "");
     }
     return QString();
   }
 
   void SetLastFileSavePath(const QString& path) const
   {
     berry::IPreferences::Pointer prefs = GetPreferences();
     if (prefs.IsNotNull())
     {
       prefs->Put("LastFileSavePath", path);
       prefs->Flush();
     }
   }
 
   void SetEnabled(berry::ISelection::ConstPointer selection)
   {
     mitk::DataNodeSelection::ConstPointer nodeSelection = selection.Cast<const mitk::DataNodeSelection>();
     if (nodeSelection.IsNotNull() && !selection->IsEmpty())
     {
       bool enable = false;
       std::list<mitk::DataNode::Pointer> dataNodes = nodeSelection->GetSelectedDataNodes();
       for (std::list<mitk::DataNode::Pointer>::const_iterator nodeIter = dataNodes.begin(), nodeIterEnd = dataNodes.end(); nodeIter != nodeIterEnd; ++nodeIter)
       {
         if ((*nodeIter)->GetData() != nullptr)
         {
           enable = true;
           break;
         }
       }
       m_Action->setEnabled(enable);
     }
     else
     {
       m_Action->setEnabled(false);
     }
   }
 
   berry::IWorkbenchWindow::WeakPtr m_Window;
   QAction* m_Action;
 };
 
 QmitkFileSaveAction::QmitkFileSaveAction(berry::IWorkbenchWindow::Pointer window)
   : QAction(tr("Save..."))
   , d(new QmitkFileSaveActionPrivate)
 {
   d->Init(window.GetPointer(), this);
 }
 
 QmitkFileSaveAction::QmitkFileSaveAction(const QIcon& icon, berry::IWorkbenchWindow::Pointer window)
   : QAction(tr("Save..."))
   , d(new QmitkFileSaveActionPrivate)
 {
   d->Init(window.GetPointer(), this);
   setIcon(icon);
 }
 
 QmitkFileSaveAction::QmitkFileSaveAction(const QIcon& icon, berry::IWorkbenchWindow* window)
   : QAction(tr("Save..."))
   , d(new QmitkFileSaveActionPrivate)
 {
   d->Init(window, this);
   setIcon(icon);
 }
 
 QmitkFileSaveAction::~QmitkFileSaveAction()
 {
 }
 
 void QmitkFileSaveAction::Run()
 {
   // get the list of selected base data objects
   mitk::DataNodeSelection::ConstPointer selection = d->m_Window.Lock()->GetSelectionService()->GetSelection().Cast<const mitk::DataNodeSelection>();
   if (selection.IsNull() || selection->IsEmpty())
   {
     MITK_ERROR << "Assertion failed: data node selection is nullptr or empty";
     return;
   }
 
   std::list<mitk::DataNode::Pointer> dataNodes = selection->GetSelectedDataNodes();
 
   std::vector<const mitk::BaseData*> data;
   QStringList names;
   for (std::list<mitk::DataNode::Pointer>::const_iterator nodeIter = dataNodes.begin(), nodeIterEnd = dataNodes.end(); nodeIter != nodeIterEnd; ++nodeIter)
   {
     data.push_back((*nodeIter)->GetData());
     std::string name;
     (*nodeIter)->GetStringProperty("name", name);
     names.push_back(QString::fromStdString(name));
   }
 
   QString path;
 
   if (1 == data.size())
   {
     if (nullptr != data[0])
     {
       auto pathProperty = data[0]->GetConstProperty("path");
 
       if (pathProperty.IsNotNull())
         path = QFileInfo(QString::fromStdString(pathProperty->GetValueAsString())).canonicalPath();
     }
 
     if (path.isEmpty())
       path = GetParentPath(dataNodes.front());
   }
 
   if (path.isEmpty())
     path = d->GetLastFileSavePath();
 
   try
   {
     auto setPathProperty = true;
     auto fileNames = QmitkIOUtil::Save(data, names, path, d->m_Action->parentWidget(), setPathProperty);
 
     if (!fileNames.empty())
       d->SetLastFileSavePath(QFileInfo(fileNames.back()).absolutePath());
   }
   catch (const mitk::Exception& e)
   {
     MITK_INFO << e;
     return;
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.cest/src/internal/QmitkCESTStatisticsView.h b/Plugins/org.mitk.gui.qt.cest/src/internal/QmitkCESTStatisticsView.h
index 9954b55c84..444a12b7a0 100644
--- a/Plugins/org.mitk.gui.qt.cest/src/internal/QmitkCESTStatisticsView.h
+++ b/Plugins/org.mitk.gui.qt.cest/src/internal/QmitkCESTStatisticsView.h
@@ -1,133 +1,130 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef QmitkCESTStatisticsView_h
 #define QmitkCESTStatisticsView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 #include <QmitkSliceNavigationListener.h>
 
 #include "ui_QmitkCESTStatisticsViewControls.h"
 #include <QmitkImageStatisticsCalculationJob.h>
 
 #include <mitkPointSet.h>
 
 #include <mitkIRenderWindowPartListener.h>
 
 /**
   \brief QmitkCESTStatisticsView
 
   \warning  Basic statistics view for CEST data.
 
   \sa QmitkAbstractView
   \ingroup ${plugin_target}_internal
 */
 class QmitkCESTStatisticsView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     /*!
     \brief default constructor */
     QmitkCESTStatisticsView(QObject *parent = nullptr, const char *name = nullptr);
     /*!
     \brief default destructor */
     ~QmitkCESTStatisticsView() override;
 
   protected slots:
 
     /// \brief Called when the user clicks the GUI button
     void OnThreeDimToFourDimPushButtonClicked();
 
     /// \brief takes care of processing the computed data
     void OnThreadedStatisticsCalculationEnds();
 
     /// \brief Toggle whether or not the plot uses a fixed x range
     void OnFixedRangeCheckBoxToggled(bool state);
 
     /// \brief Adapt axis scale when manual ranges are set
     void OnFixedRangeDoubleSpinBoxChanged();
 
     /// \brief What to do if the crosshair moves
     void OnSliceChanged();
 
   protected:
 
     void CreateQtPartControl(QWidget *parent) override;
 
     void SetFocus() override;
 
     void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
     void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
-    /// \brief called by QmitkFunctionality when DataManager's selection has changed
     void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
                                      const QList<mitk::DataNode::Pointer>& nodes ) override;
 
     /// parse string and set data vector returns true if succesfull
     bool SetZSpectrum(mitk::StringProperty* zSpectrumProperty);
 
     /** Checks whether the currently set data appears reasonable
     */
     bool DataSanityCheck();
 
     /** Fills the plot based on a point set
     *
     * This will only use the first timestep
     */
     template <typename TPixel, unsigned int VImageDimension>
     void PlotPointSet(itk::Image<TPixel, VImageDimension>* image);
 
     /** Deletes all data
     */
     void Clear();
 
     /** Remove MZeros
     *
     * Will remove the data for the M0 images from the given input
     */
     void RemoveMZeros(QmitkPlotWidget::DataVector& xValues, QmitkPlotWidget::DataVector& yValues);
     void RemoveMZeros(QmitkPlotWidget::DataVector& xValues, QmitkPlotWidget::DataVector& yValues, QmitkPlotWidget::DataVector& stdDevs);
 
     /** Copies the first timestep of a segmentation to all others
     */
     template <typename TPixel, unsigned int VImageDimension>
     void CopyTimesteps(itk::Image<TPixel, VImageDimension>* image);
 
     Ui::QmitkCESTStatisticsViewControls m_Controls;
     QmitkImageStatisticsCalculationJob* m_CalculatorJob;
     QmitkPlotWidget::DataVector m_zSpectrum;
     mitk::Image::Pointer m_ZImage;
     mitk::Image::Pointer m_MaskImage;
     mitk::PlanarFigure::Pointer m_MaskPlanarFigure;
     mitk::PointSet::Pointer m_PointSet;
     mitk::PointSet::Pointer m_CrosshairPointSet;
 
     QmitkSliceNavigationListener m_SliceChangeListener;
 
     itk::TimeStamp m_selectedNodeTime;
     itk::TimeStamp m_currentPositionTime;
     /** @brief currently valid selected position in the inspector*/
     mitk::Point3D m_currentSelectedPosition;
     mitk::TimePointType m_currentSelectedTimePoint;
 
 };
 
 #endif // QmitkCESTStatisticsView_h
diff --git a/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.cpp b/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.cpp
index a64a782ba3..01a7afcf61 100644
--- a/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.cpp
+++ b/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.cpp
@@ -1,624 +1,619 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 // STD
 #include <stack>
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "ClassificationRegionGrow.h"
 
 // Qt
 #include <QMessageBox>
 #include <qgroupbox.h>
 #include <qsignalmapper.h>
 
 //mitk image
 #include <mitkImage.h>
 #include <QmitkDataStorageComboBox.h>
-//#include <ctkSliderWidget.h>
-//#include <mitkPointSet.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateOr.h>
 #include "mitkVigraRandomForestClassifier.h"
 #include "mitkCLUtil.h"
 #include "qboxlayout.h"
 #include <mitkIOUtil.h>
 
 #include "Eigen/Dense"
 
 #include <mitkImageAccessByItk.h>
 #include <mitkSliceNavigationController.h>
 #include <vnl/vnl_random.h>
 
 #include <itkNeighborhoodFunctorImageFilter.h>
 #include <itkFirstOrderStatisticsFeatureFunctor.h>
 #include <itkNeighborhood.h>
 #include <itkHessianMatrixEigenvalueImageFilter.h>
 #include <itkStructureTensorEigenvalueImageFilter.h>
 #include <itkLineHistogramBasedMassImageFilter.h>
 #include <mitkHistogramGenerator.h>
 
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionConstIterator.h>
 
-//#include <mitkRandomForestAccurecyWeighting.h>
 #include "mitkLabelSetImage.h"
-//#include <vigra\multi_array.hxx>
 
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 
 #include <QFuture>
 #include <QFutureWatcher>
 #include <QtConcurrentRun>
-//#include <mitkPointSetDataInteractor.h>
 #include <QmitkIOUtil.h>
 const std::string ClassificationRegionGrow::VIEW_ID = "org.mitk.views.ClassificationRegionGrow";
 
 void ClassificationRegionGrow::SetFocus()
 {
   //  m_Controls.buttonPerformImageProcessing->setFocus();
 }
 
 void ClassificationRegionGrow::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
   m_CalculateFeatures = true;
   m_BlockManualSegmentation = false;
   m_BlockPostProcessing = false;
 
   m_Controls.groupLearningParameter->setVisible(false);
   m_Controls.groupFeatureSelection->setVisible(false);
 
   QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
   QmitkDataStorageComboBox * cb_maskimage= new QmitkDataStorageComboBox(this->GetDataStorage(),mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   QmitkDataStorageComboBox * cb_baseimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
 
   m_Controls.m_InputImageLayout->addWidget(cb_inputimage);
   m_Controls.m_MaskImageLayout->addWidget(cb_maskimage);
   m_Controls.StartingPointLayout->addWidget(cb_baseimage);
   m_Controls.addInputButton->setIcon(QIcon::fromTheme("list-add"));
   m_Controls.removeInputButton->setIcon(QIcon::fromTheme("edit-delete"));
 
   connect( cb_inputimage, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnInitializeSession(const mitk::DataNode*)));
   connect( cb_maskimage, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnInitializeSession(const mitk::DataNode*)));
   connect(m_Controls.SelectAdvancedParameter, SIGNAL(toggled(bool)), m_Controls.groupLearningParameter, SLOT(setVisible(bool)));
   connect(m_Controls.SelectAdvancedParameter, SIGNAL(toggled(bool)), m_Controls.groupFeatureSelection, SLOT(setVisible(bool)));
   connect(m_Controls.SelectSimpleParameters, SIGNAL(toggled(bool)), m_Controls.parameterWidget, SLOT(setVisible(bool)));
   connect(m_Controls.m_DoAutomaticSecmentation, SIGNAL( clicked()), this, SLOT(DoAutomSegmentation()));
   connect(m_Controls.removeInputButton, SIGNAL(clicked()), this, SLOT(RemoveItemFromLabelList()));
   connect(m_Controls.addInputButton, SIGNAL(clicked()), this, SLOT(AddInputField()));
 
   connect(m_Controls.UseIntensity, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.Gauss1, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.Gauss2, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.Gauss3, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.Gauss4, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.Gauss5, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.DoG1, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.DoG2, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.DoG3, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.DoG4, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.DoG5, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LoG1, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LoG2, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LoG3, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LoG4, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LoG5, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.HoG1, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.HoG2, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.HoG3, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.HoG4, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.HoG5, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LH1, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LH2, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LH3, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
   connect(m_Controls.LH4, SIGNAL(toggled(bool)), this, SLOT(OnFeatureSettingsChanged()));
 }
 
 void ClassificationRegionGrow::AddInputField()
 {
   QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
   //QPushButton * lockButton = new QPushButton();
   //lockButton->setText("");
   //lockButton->setMinimumWidth(40);
   //lockButton->setCheckable(true);
   //lockButton->setIcon(QApplication::style()->standardIcon(QStyle::SP_MediaStop));
 
   QHBoxLayout *layout = new QHBoxLayout;
   layout->addWidget(cb_inputimage,100);
   //layout->addWidget(lockButton,1);
   m_Controls.m_InputImageLayout->addLayout(layout);
   connect(cb_inputimage, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnInitializeSession(const mitk::DataNode*)));
 }
 
 void ClassificationRegionGrow::RemoveItemFromLabelList()
 {
   auto numberOfElements = m_Controls.m_InputImageLayout->count();
   auto lastItem = m_Controls.m_InputImageLayout->itemAt(numberOfElements-1);
   QHBoxLayout *layout = dynamic_cast<QHBoxLayout *>(lastItem);
   while (QLayoutItem* item = layout->takeAt(0))
   {
     if (QWidget* widget = item->widget())
         widget->deleteLater();
     delete item;
   }
   m_Controls.m_InputImageLayout->removeItem(lastItem);
   delete lastItem;
 
 }
 
 void ClassificationRegionGrow::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*source*/,
                                                      const QList<mitk::DataNode::Pointer>& nodes )
 {
   // iterate all selected objects, adjust warning visibility
   foreach( mitk::DataNode::Pointer node, nodes )
   {
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       return;
     }
   }
 }
 
 void ClassificationRegionGrow::OnInitializeSession(const mitk::DataNode *)
 {
   OnFeatureSettingsChanged();
 }
 
 void ClassificationRegionGrow::ProcessFeatureImages(const mitk::Image::Pointer & raw_image)
 {
   // RAW
   if (m_Controls.UseIntensity->isChecked()) {
     m_FeatureImageVector.push_back(raw_image);
   }
 
   // GAUSS
   if (m_Controls.Gauss1->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::GaussianFilter(raw_image, smoothed, 1);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.Gauss2->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::GaussianFilter(raw_image, smoothed, 2);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.Gauss3->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::GaussianFilter(raw_image, smoothed, 3);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.Gauss4->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::GaussianFilter(raw_image, smoothed, 4);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.Gauss5->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::GaussianFilter(raw_image, smoothed, 5);
     m_FeatureImageVector.push_back(smoothed);
   }
 
   // Difference of Gaussian
   if (m_Controls.DoG1->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::DifferenceOfGaussianFilter(raw_image, smoothed, 1,0.8);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.DoG2->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::DifferenceOfGaussianFilter(raw_image, smoothed, 2, 1.8);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.DoG3->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::DifferenceOfGaussianFilter(raw_image, smoothed, 3, 2.6);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.DoG4->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::DifferenceOfGaussianFilter(raw_image, smoothed, 4, 3.4);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.DoG5->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::DifferenceOfGaussianFilter(raw_image, smoothed, 5, 4.3);
     m_FeatureImageVector.push_back(smoothed);
   }
 
   // Laplacian of Gaussian
   if (m_Controls.LoG1->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::LaplacianOfGaussianFilter(raw_image, smoothed, 1);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.LoG2->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::LaplacianOfGaussianFilter(raw_image, smoothed, 2);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.LoG3->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::LaplacianOfGaussianFilter(raw_image, smoothed, 3);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.LoG4->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::LaplacianOfGaussianFilter(raw_image, smoothed, 4);
     m_FeatureImageVector.push_back(smoothed);
   }
   if (m_Controls.LoG5->isChecked())
   {
     mitk::Image::Pointer smoothed;
     mitk::CLUtil::LaplacianOfGaussianFilter(raw_image, smoothed, 5);
     m_FeatureImageVector.push_back(smoothed);
   }
 
   // Hessian of Gaussian
   if (m_Controls.HoG1->isChecked())
   {
     mitk::CLUtil::HessianOfGaussianFilter(raw_image, m_FeatureImageVector, 1);
   }
   if (m_Controls.HoG2->isChecked())
   {
     mitk::CLUtil::HessianOfGaussianFilter(raw_image, m_FeatureImageVector, 2);
   }
   if (m_Controls.HoG3->isChecked())
   {
     mitk::CLUtil::HessianOfGaussianFilter(raw_image, m_FeatureImageVector, 3);
   }
   if (m_Controls.HoG4->isChecked())
   {
     mitk::CLUtil::HessianOfGaussianFilter(raw_image, m_FeatureImageVector, 4);
   }
   if (m_Controls.HoG5->isChecked())
   {
     mitk::CLUtil::HessianOfGaussianFilter(raw_image, m_FeatureImageVector, 5);
   }
 
   // LocalHistogram
   if (m_Controls.LH1->isChecked())
   {
     mitk::CLUtil::LocalHistogram(raw_image, m_FeatureImageVector, 5,3);
   }
   if (m_Controls.LH2->isChecked())
   {
     mitk::CLUtil::LocalHistogram(raw_image, m_FeatureImageVector, 5, 5);
   }
   if (m_Controls.LH3->isChecked())
   {
     mitk::CLUtil::LocalHistogram(raw_image, m_FeatureImageVector, 10, 3);
   }
   if (m_Controls.LH4->isChecked())
   {
     mitk::CLUtil::LocalHistogram(raw_image, m_FeatureImageVector, 10, 5);
   }
 }
 
 void ClassificationRegionGrow::OnFeatureSettingsChanged()
 {
   MITK_INFO << "FeatureSettingsChanged";
   m_CalculateFeatures = true;
 }
 
 void ClassificationRegionGrow::DoAutomSegmentation()
 {
   MITK_INFO << "Start Automatic Segmentation ...";
   // Load Images from registration process
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_InputImageLayout->itemAt(1)->widget());
   QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_MaskImageLayout->itemAt(1)->widget());
   mitk::Image::Pointer raw_image;
   mitk::Image::Pointer mask_image;
   if ((cb_image != nullptr) || (cb_maskimage != nullptr))
   {
     raw_image = dynamic_cast<mitk::Image *>(cb_image->GetSelectedNode()->GetData());
     mask_image = dynamic_cast<mitk::Image *>(cb_maskimage->GetSelectedNode()->GetData());
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
 
   if (raw_image.IsNull() || mask_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   std::vector<mitk::Image::Pointer> imageList;
   imageList.push_back(raw_image);
   for (int i = 2; i < m_Controls.m_InputImageLayout->count(); ++i)
   {
     QLayout* layout = dynamic_cast<QLayout*>(m_Controls.m_InputImageLayout->itemAt(i));
     MITK_INFO << layout;
     QmitkDataStorageComboBox * tmp_cb_image = dynamic_cast<QmitkDataStorageComboBox *>(layout->itemAt(0)->widget());
     MITK_INFO << tmp_cb_image;
     if (tmp_cb_image)
     {
       mitk::Image::Pointer tmp_image = dynamic_cast<mitk::Image *>(tmp_cb_image);
         if (tmp_image.IsNotNull())
       {
         MITK_INFO << "Adding Image...";
         imageList.push_back(tmp_image);
       }
     }
   }
 
   MITK_INFO << "Start Feature Calculation ...";
   if(m_CalculateFeatures)
   {
     m_FeatureImageVector.clear();
     for (auto img : imageList)
     {
       ProcessFeatureImages(img);
     }
     m_CalculateFeatures = false;
     if (m_Controls.checkAddFeaturesToDataManager->isChecked())
     {
       for (std::size_t i = 0; i < m_FeatureImageVector.size(); ++i)
       {
         auto newName = "Feature_" + std::to_string(i);
         AddAsDataNode(m_FeatureImageVector[i].GetPointer(), newName);
       }
     }
   }
 
   MITK_INFO << "Start Classifier Training ...";
   TrainClassifier(raw_image, mask_image);
 
   MITK_INFO << "Predict extended Segmentation ...";
   PredictSegmentation(raw_image, mask_image);
 }
 
 
 void ClassificationRegionGrow::TrainClassifier(const mitk::Image::Pointer & raw_image, const mitk::Image::Pointer & mask_image)
 {
   typedef itk::Image<double, 3> DoubleImageType;
   typedef itk::Image<short, 3> ShortImageType;
 
   DoubleImageType::Pointer input;
   ShortImageType::Pointer mask;
   mitk::CastToItkImage(raw_image, input);
   mitk::CastToItkImage(mask_image, mask);
 
   int numberOfSegmentedVoxel = 0;
   int numberOfFeatures = m_FeatureImageVector.size();
 
   auto maskIter = itk::ImageRegionConstIteratorWithIndex<ShortImageType>(mask, mask->GetLargestPossibleRegion());
   m_SegmentedLocations.clear();
   m_SegmentedOrganLocations.clear();
 
   MITK_INFO << "Count Segmentation Size ...";
   while ( ! maskIter.IsAtEnd())
   {
     if (maskIter.Value() > 0)
     {
       m_SegmentedLocations.push_back(maskIter.GetIndex());
       numberOfSegmentedVoxel++;
       if (maskIter.Value() > 1)
       {
         m_SegmentedOrganLocations.push_back(maskIter.GetIndex());
       }
     }
     ++maskIter;
   }
   MITK_INFO << "Sizes: " << numberOfSegmentedVoxel << " " << m_SegmentedOrganLocations.size();
 
   Eigen::MatrixXi Y_train = mitk::CLUtil::Transform<int>(mask_image, mask_image);
   Eigen::MatrixXd X_train = Eigen::MatrixXd(numberOfSegmentedVoxel, numberOfFeatures);
   unsigned int index = 0;
 
   MITK_INFO << "Convert Training Data to Eigen Matrix ...";
   for (const auto & image : m_FeatureImageVector)
   {
     X_train.col(index) = mitk::CLUtil::Transform<double>(image, mask_image);
     ++index;
   }
 
   MITK_INFO << "Classifier Training ...";
   m_Classifier = mitk::VigraRandomForestClassifier::New();
   //this->m_Controls.Maximum
   m_Classifier->SetTreeCount(m_Controls.NumberOfTrees->value());
   m_Classifier->SetSamplesPerTree(m_Controls.SamplesPerTree->value());
   m_Classifier->SetMinimumSplitNodeSize(m_Controls.MinimumSamplesPerNode->value());
   m_Classifier->SetMaximumTreeDepth(m_Controls.MaximumTreeDepth->value());
   m_Classifier->Train(X_train, Y_train);
 }
 
 static void addNeighbours(std::stack<itk::Index<3> > &stack, itk::Index<3> idx)
 {
   idx[0] -= 1;
   stack.push(idx);
   idx[0] += 2;
   stack.push(idx);
   idx[0] -= 1;
   idx[1] -= 1;
   stack.push(idx);
   idx[1] += 2;
   stack.push(idx);
   idx[1] -= 1;
   idx[2] -= 1;
   stack.push(idx);
   idx[2] += 2;
   stack.push(idx);
 }
 
 void ClassificationRegionGrow::PredictSegmentation(const mitk::Image::Pointer & raw_image, const mitk::Image::Pointer & mask_image)
 {
   typedef itk::Image<double, 3> DoubleImageType;
   typedef itk::Image<unsigned short, 3> ShortImageType;
 
   DoubleImageType::Pointer input;
   ShortImageType::Pointer mask;
   mitk::CastToItkImage(raw_image, input);
   mitk::CastToItkImage(mask_image, mask);
 
   std::vector<DoubleImageType::Pointer > featureImages;
   for (auto fimage : m_FeatureImageVector)
   {
     DoubleImageType::Pointer feature;
     mitk::CastToItkImage(fimage, feature);
     featureImages.push_back(feature);
   }
 
   ShortImageType::Pointer usedLocation = ShortImageType::New();
   usedLocation->SetRegions(mask->GetLargestPossibleRegion());
   usedLocation->Allocate();
   usedLocation->FillBuffer(0);
 
   ShortImageType::Pointer resultSegmentation = ShortImageType::New();
   if (m_Controls.UpdateImage->isChecked()) {
     QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.StartingPointLayout->itemAt(2)->widget());
     mitk::Image::Pointer base_image = dynamic_cast<mitk::Image *>(cb_maskimage->GetSelectedNode()->GetData());
     mitk::CastToItkImage(base_image, resultSegmentation);
   }
   else {
 
     resultSegmentation->SetRegions(mask->GetLargestPossibleRegion());
     resultSegmentation->Allocate();
     if (m_Controls.SegmentBackground->isChecked())
     {
       resultSegmentation->FillBuffer(1);
     }
     else {
       resultSegmentation->FillBuffer(0);
     }
   }
 
   // Fill list of Stacks
   std::vector<std::stack<itk::Index<3> > > listOfStacks;
   while (m_SegmentedOrganLocations.size() > 0)
   {
     auto currentLocation = m_SegmentedOrganLocations.back();
     m_SegmentedOrganLocations.pop_back();
     std::size_t cValue = mask->GetPixel(currentLocation);
     resultSegmentation->SetPixel(currentLocation, cValue);
     usedLocation->SetPixel(currentLocation, 1000);
     while (listOfStacks.size() < cValue+1)
     {
       listOfStacks.push_back(std::stack<itk::Index<3> >());
     }
     addNeighbours(listOfStacks[cValue],currentLocation);
   }
 
 
   int countPredicted = 0;
   bool connectAllLabels = m_Controls.localGrowing->isChecked();
   //m_SegmentedOrganLocations.reserve(10000);
 
   Eigen::MatrixXd currentX = Eigen::MatrixXd(1, featureImages.size());
   vigra::MultiArrayView<2, double> X(vigra::Shape2(currentX.rows(), currentX.cols()), currentX.data());
   auto outLabel = Eigen::MatrixXi(currentX.rows(), 1);
   vigra::MultiArrayView<2, int> Y(vigra::Shape2(currentX.rows(), 1), outLabel.data());
   for (std::size_t i = 2; i < listOfStacks.size(); ++i)
   {
     while (listOfStacks[i].size() > 0)
     {
       auto currentLocation = listOfStacks[i].top();
       listOfStacks[i].pop();
       if (!mask->GetLargestPossibleRegion().IsInside(currentLocation))
       {
         continue;
       }
       if (usedLocation->GetPixel(currentLocation) > i)
       {
         continue;
       }
       usedLocation->SetPixel(currentLocation, i+1);
 
 
       for (std::size_t f = 0; f < featureImages.size(); ++f)
       {
         currentX(0, f) = featureImages[f]->GetPixel(currentLocation);
       }
 
       m_Classifier->GetRandomForest().predictLabels(X, Y);
       ++countPredicted;
       if ((static_cast<unsigned int>(Y(0, 0)) ==  i ) ||
         ((Y(0, 0) > 1) && (connectAllLabels)))
       {
         resultSegmentation->SetPixel(currentLocation, std::abs(Y(0, 0)));
         addNeighbours(listOfStacks[i], currentLocation);
       }
     }
   }
   MITK_INFO << "Number of Predictions: " << countPredicted;
 
   MITK_INFO << "Finished Segmentation...";
   mitk::Image::Pointer result;
   mitk::CastToMitkImage(resultSegmentation, result);
   result->SetOrigin(raw_image->GetGeometry()->GetOrigin());
   result->SetSpacing(raw_image->GetGeometry()->GetSpacing());
   mitk::LabelSetImage::Pointer labelResult = mitk::LabelSetImage::New();
   labelResult->InitializeByLabeledImage(result);
   mitk::LabelSetImage::Pointer oldLabelSet = dynamic_cast<mitk::LabelSetImage *>(mask_image.GetPointer());
   labelResult->AddLabelSetToLayer(labelResult->GetActiveLayer(),oldLabelSet->GetLabelSet());
   MITK_INFO << "Passing Back...";
   AddAsDataNode(labelResult.GetPointer(), "ResultSegmentation");
 }
 
 mitk::DataNode::Pointer ClassificationRegionGrow::AddAsDataNode(const mitk::BaseData::Pointer & data_, const std::string & name )
 {
   mitk::DataNode::Pointer node = nullptr;
   node = this->GetDataStorage()->GetNamedNode(name);
 
   if(node.IsNull())
   {
     node = mitk::DataNode::New();
     node->SetData(data_);
     node->SetName(name);
     this->GetDataStorage()->Add(node);
   }else{
 
     if(dynamic_cast<mitk::Image*>(node->GetData()) && dynamic_cast<mitk::Image*>(data_.GetPointer()))
     {
       mitk::Image::Pointer target_image = dynamic_cast<mitk::Image*>(node->GetData());
       mitk::Image::Pointer source_image = dynamic_cast<mitk::Image*>(data_.GetPointer());
       mitk::ImageReadAccessor ra(source_image);
       target_image->SetImportVolume(const_cast<void *>(ra.GetData()));
       this->RequestRenderWindowUpdate();
     }
 
     if(dynamic_cast<mitk::VigraRandomForestClassifier*>(node->GetData()) && dynamic_cast<mitk::VigraRandomForestClassifier*>(data_.GetPointer()))
     {
       node->SetData(data_);
       node->Modified();
     }
 
   }
 
   return node;
 }
diff --git a/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.h b/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.h
index bca9dcd73e..04987f3a46 100644
--- a/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.h
+++ b/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationRegionGrow.h
@@ -1,110 +1,99 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef ClassificationRegionGrow_h
 #define ClassificationRegionGrow_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_ClassificationRegionGrowControls.h"
 #include <mitkImage.h>
 #include <itkConstNeighborhoodIterator.h>
 #include <itkNeighborhoodFunctorImageFilter.h>
 #include <itkFirstOrderStatisticsFeatureFunctor.h>
 
 #include <mitkImageCast.h>
-//#include <vigra/tensorutilities.hxx>
-//#include <vigra/convolution.hxx>
-//#include <vigra/multi_array.hxx>
-#include <mitkPointSet.h>
 #include <itkHistogram.h>
 #include <QFutureWatcher>
-#include "QmitkPointListViewWidget.h"
-#include <mitkPointSetDataInteractor.h>
 
 #include <mitkVigraRandomForestClassifier.h>
 /**
 \brief ClassificationRegionGrow
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
 \sa QmitkAbstractView
 \ingroup ${plugin_target}_internal
 */
 
-
-//class QmitkPointListWidget;
 class ctkSliderWidget;
 class ClassificationRegionGrow : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   bool m_CalculateFeatures;
 
   std::vector<mitk::Image::Pointer> m_FeatureImageVector;
   std::vector<mitk::Image::Pointer> m_ResultImageVector;
 
   bool m_BlockManualSegmentation;
   QFutureWatcher<std::vector<mitk::Image::Pointer>> m_ManualSegmentationFutureWatcher;
 
   bool m_BlockPostProcessing;
   QFutureWatcher<std::vector<mitk::Image::Pointer>> m_PostProcessingFutureWatcher;
 
   public slots:
 
     /// \brief Called when the user clicks the GUI button
     void DoAutomSegmentation();
     void AddInputField();
 
     void RemoveItemFromLabelList();
 
     void OnFeatureSettingsChanged();
     void OnInitializeSession(const mitk::DataNode*);
 
 protected:
   std::vector<itk::Index<3> > m_SegmentedLocations;
   std::vector<itk::Index<3> > m_SegmentedOrganLocations;
 
 
 
   typedef float MeasurementType;
   typedef itk::Statistics::Histogram< MeasurementType,
     itk::Statistics::DenseFrequencyContainer2 > HistogramType;
 
 
   void CreateQtPartControl(QWidget *parent) override;
   void SetFocus() override;
 
   mitk::DataNode::Pointer AddAsDataNode(const mitk::BaseData::Pointer & data_, const std::string & name );
 
   void ProcessFeatureImages(const mitk::Image::Pointer & raw_image);
   void TrainClassifier(const mitk::Image::Pointer & raw_image, const mitk::Image::Pointer & mask_image);
   void PredictSegmentation(const mitk::Image::Pointer & raw_image, const mitk::Image::Pointer & mask_image);
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
   void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
     const QList<mitk::DataNode::Pointer>& nodes ) override;
 
   Ui::ClassificationRegionGrowControls m_Controls;
 
   mitk::VigraRandomForestClassifier::Pointer m_Classifier;
 };
 
 #endif // ClassificationRegionGrow_h
diff --git a/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationSegmentation.cpp b/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationSegmentation.cpp
index 1b466f9f58..3c593e5c3c 100644
--- a/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationSegmentation.cpp
+++ b/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationSegmentation.cpp
@@ -1,975 +1,969 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "ClassificationSegmentation.h"
 
 // Qt
 #include <QMessageBox>
 
 //mitk image
 #include <mitkImage.h>
 #include <QmitkDataStorageComboBox.h>
 #include <ctkSliderWidget.h>
 #include <mitkPointSet.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateOr.h>
 #include "mitkVigraRandomForestClassifier.h"
 #include "mitkCLUtil.h"
 #include "qboxlayout.h"
 #include <mitkIOUtil.h>
 
 #include "Eigen/Dense"
 
 #include <mitkImageAccessByItk.h>
 #include <mitkSliceNavigationController.h>
 #include <vnl/vnl_random.h>
 
 #include <itkNeighborhoodFunctorImageFilter.h>
 #include <itkFirstOrderStatisticsFeatureFunctor.h>
 #include <itkNeighborhood.h>
 #include <itkHessianMatrixEigenvalueImageFilter.h>
 #include <itkStructureTensorEigenvalueImageFilter.h>
 #include <itkLineHistogramBasedMassImageFilter.h>
 #include <mitkHistogramGenerator.h>
 
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionConstIterator.h>
 
-//#include <mitkRandomForestAccurecyWeighting.h>
-
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 
 #include <QFuture>
 #include <QFutureWatcher>
 #include <QtConcurrentRun>
-#include <mitkPointSetDataInteractor.h>
 #include <QmitkIOUtil.h>
 const std::string ClassificationSegmentation::VIEW_ID = "org.mitk.views.classificationsegmentation";
 
 void ClassificationSegmentation::SetFocus()
 {
   //  m_Controls.buttonPerformImageProcessing->setFocus();
 }
 
 void ClassificationSegmentation::OnButtonCSFToggle(bool checked)
 {
-  //  m_PointListWidget->SetPointSet(dynamic_cast<mitk::PointSet *>(m_PointSetList[0]->GetData()));
   if(checked)
     m_PointSetDataInteractor->SetDataNode(m_PointSetList[0]);
   else
     m_PointSetDataInteractor->SetDataNode(nullptr);
 }
 
 void ClassificationSegmentation::OnButtonLESToggle(bool checked)
 {
-  //  m_PointListWidget->SetPointSet(dynamic_cast<mitk::PointSet *>(m_PointSetList[1]->GetData()));
   if(checked)
     m_PointSetDataInteractor->SetDataNode(m_PointSetList[1]);
   else
     m_PointSetDataInteractor->SetDataNode(nullptr);
 }
 
 void ClassificationSegmentation::OnButtonBRAToggle(bool checked)
 {
-  //  m_PointListWidget->SetPointSet(dynamic_cast<mitk::PointSet *>(m_PointSetList[2]->GetData()));
   if(checked)
     m_PointSetDataInteractor->SetDataNode(m_PointSetList[2]);
   else
     m_PointSetDataInteractor->SetDataNode(nullptr);
 }
 
 void ClassificationSegmentation::OnButtonNoInteractionToggle(bool checked)
 {
   if(checked)
     m_PointSetDataInteractor->SetDataNode(nullptr);
 }
 
 void ClassificationSegmentation::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
   m_CalculateFeatures = true;
   m_BlockManualSegmentation = false;
   m_BlockPostProcessing = false;
 
   QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
   QmitkDataStorageComboBox * cb_maskimage= new QmitkDataStorageComboBox(this->GetDataStorage(),mitk::TNodePredicateDataType<mitk::Image>::New());
   QmitkDataStorageComboBox * cb_classifer= new QmitkDataStorageComboBox(this->GetDataStorage(),mitk::TNodePredicateDataType<mitk::VigraRandomForestClassifier>::New());
 
   m_Controls.m_InputImageLayout->addWidget(cb_inputimage);
   m_Controls.m_MaskImageLayout->addWidget(cb_maskimage);
   m_Controls.m_ClassifierLayout->addWidget(cb_classifer);
 
   m_Controls.m_ParameterLayout->layout()->addWidget(new QLabel("Gauss Sigma"));
   m_GaussSlider = new ctkSliderWidget();
   m_GaussSlider->setMinimum(0);
   m_GaussSlider->setMaximum(10);
   m_GaussSlider->setValue(1);
   m_Controls.m_ParameterLayout->layout()->addWidget(m_GaussSlider);
 
   m_Controls.m_ParameterLayout->layout()->addWidget(new QLabel("Hessian Sigma"));
   m_HessianSlider = new ctkSliderWidget();
   m_HessianSlider->setMinimum(0);
   m_HessianSlider->setMaximum(10);
   m_HessianSlider->setValue(3);
   m_Controls.m_ParameterLayout->layout()->addWidget(m_HessianSlider);
 
   m_Controls.m_ParameterLayout->layout()->addWidget(new QLabel("Structure Tensor Inner and Outer Scale"));
   m_STInnerSlider = new ctkSliderWidget();
   m_STInnerSlider->setMinimum(0);
   m_STInnerSlider->setMaximum(10);
   m_STInnerSlider->setValue(1.5);
   m_Controls.m_ParameterLayout->layout()->addWidget(m_STInnerSlider);
 
   m_STOuterSlider = new ctkSliderWidget();
   m_STOuterSlider->setMinimum(0);
   m_STOuterSlider->setMaximum(10);
   m_STOuterSlider->setValue(3);
   m_Controls.m_ParameterLayout->layout()->addWidget(m_STOuterSlider);
 
   m_Controls.m_PostProcessingLayout->layout()->addWidget(new QLabel("Probability map smoothing"));
   m_GaussCSFSlider = new ctkSliderWidget;
   m_GaussCSFSlider->setMinimum(0);
   m_GaussCSFSlider->setMaximum(10);
   m_GaussCSFSlider->setValue(1.5);
   m_Controls.m_PostProcessingLayout->layout()->addWidget(m_GaussCSFSlider);
 
   m_GaussLESSlider = new ctkSliderWidget;
   m_GaussLESSlider->setMinimum(0);
   m_GaussLESSlider->setMaximum(10);
   m_GaussLESSlider->setValue(3);
   m_Controls.m_PostProcessingLayout->layout()->addWidget(m_GaussLESSlider);
 
   m_GaussBRASlider = new ctkSliderWidget;
   m_GaussBRASlider->setMinimum(0);
   m_GaussBRASlider->setMaximum(10);
   m_GaussBRASlider->setValue(0.5);
   m_Controls.m_PostProcessingLayout->layout()->addWidget(m_GaussBRASlider);
 
   m_Controls.m_PostProcessingLayout->layout()->addWidget(new QLabel("Probability map weighting"));
   m_WeightCSFSlider = new ctkSliderWidget;
   m_WeightCSFSlider->setMinimum(0.0);
   m_WeightCSFSlider->setMaximum(2.0);
   m_WeightCSFSlider->setValue(1.0);
   m_WeightCSFSlider->setSingleStep(0.1);
   m_Controls.m_PostProcessingLayout->layout()->addWidget(m_WeightCSFSlider);
 
   m_WeightLESSlider = new ctkSliderWidget;
   m_WeightLESSlider->setMinimum(0.0);
   m_WeightLESSlider->setMaximum(2.0);
   m_WeightLESSlider->setValue(1.0);
   m_WeightLESSlider->setSingleStep(0.1);
   m_Controls.m_PostProcessingLayout->layout()->addWidget(m_WeightLESSlider);
 
   m_WeightBRASlider = new ctkSliderWidget;
   m_WeightBRASlider->setMinimum(0.0);
   m_WeightBRASlider->setMaximum(2.0);
   m_WeightBRASlider->setValue(1.0);
   m_WeightBRASlider->setSingleStep(0.1);
   m_Controls.m_PostProcessingLayout->layout()->addWidget(m_WeightBRASlider);
 
   m_PointSetDataInteractor = mitk::PointSetDataInteractor::New();
   m_PointSetDataInteractor->LoadStateMachine("PointSet.xml");
   m_PointSetDataInteractor->SetEventConfig("PointSetConfig.xml");
 
   connect( cb_inputimage, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnInitializeSession(const mitk::DataNode*)));
   connect( cb_maskimage, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnInitializeSession(const mitk::DataNode*)));
 
   connect( m_Controls.m_SavePointsButton, SIGNAL(clicked(bool)), this, SLOT(DoSavePointsAsMask()));
 
   connect( m_Controls.m_ButtonCSFToggle, SIGNAL(toggled(bool)), this, SLOT(OnButtonCSFToggle(bool)));
   connect( m_Controls.m_ButtonLESToggle, SIGNAL(toggled(bool)), this, SLOT(OnButtonLESToggle(bool)));
   connect( m_Controls.m_ButtonBRAToggle, SIGNAL(toggled(bool)), this, SLOT(OnButtonBRAToggle(bool)));
   connect( m_Controls.m_ButtonNoInteraction, SIGNAL(toggled(bool)), this, SLOT(OnButtonNoInteractionToggle(bool)));
   connect( &m_ManualSegmentationFutureWatcher, SIGNAL(finished()), this, SLOT(ManualSegmentationFinished()));
   connect( &m_PostProcessingFutureWatcher, SIGNAL(finished()), this, SLOT(PostProcessingFinished()));
 
   //connect( m_Controls.m_AddPointSets, SIGNAL(clicked()),this, SLOT(OnAddPointSets()) );
   connect( m_GaussSlider, SIGNAL(valueChanged(double)), this, SLOT(OnFeatureSettingsChanged()));
   connect( m_HessianSlider, SIGNAL(valueChanged(double)), this, SLOT(OnFeatureSettingsChanged()));
   connect( m_STInnerSlider, SIGNAL(valueChanged(double)), this, SLOT(OnFeatureSettingsChanged()));
   connect( m_STOuterSlider, SIGNAL(valueChanged(double)), this, SLOT(OnFeatureSettingsChanged()));
 
   connect( m_GaussCSFSlider, SIGNAL(valueChanged(double)), this, SLOT(OnPostProcessingSettingsChanged()));
   connect( m_GaussLESSlider, SIGNAL(valueChanged(double)), this, SLOT(OnPostProcessingSettingsChanged()));
   connect( m_GaussBRASlider, SIGNAL(valueChanged(double)), this, SLOT(OnPostProcessingSettingsChanged()));
   connect( m_WeightCSFSlider, SIGNAL(valueChanged(double)), this, SLOT(OnPostProcessingSettingsChanged()));
   connect( m_WeightLESSlider, SIGNAL(valueChanged(double)), this, SLOT(OnPostProcessingSettingsChanged()));
   connect( m_WeightBRASlider, SIGNAL(valueChanged(double)), this, SLOT(OnPostProcessingSettingsChanged()));
 
   connect(m_Controls.m_DoAutomaticSecmentation, SIGNAL(clicked(bool)), this, SLOT(DoAutomSegmentation()));
   connect(m_Controls.m_AddForestToDataManager, SIGNAL(clicked(bool)), this, SLOT(OnAddForestToDataManager()));
 
   mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
   pointSetNode->SetName("CSF_Points.");
   pointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   pointSetNode->SetProperty("layer", mitk::IntProperty::New(1024));
   pointSetNode->SetColor(0,1.0,0);
   pointSetNode->SetDataInteractor(m_PointSetDataInteractor.GetPointer());
   m_PointSetList.push_back(pointSetNode);
   GetDataStorage()->Add(pointSetNode);
 
   pointSetNode = mitk::DataNode::New();
   pointSetNode->SetName("LES_Points.");
   pointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   pointSetNode->SetProperty("layer", mitk::IntProperty::New(1024));
   pointSetNode->SetColor(1.0,0,0);
   pointSetNode->SetDataInteractor(m_PointSetDataInteractor.GetPointer());
   m_PointSetList.push_back(pointSetNode);
   GetDataStorage()->Add(pointSetNode);
 
   pointSetNode = mitk::DataNode::New();
   pointSetNode->SetName("BRA_Points.");
   pointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   pointSetNode->SetProperty("layer", mitk::IntProperty::New(1024));
   pointSetNode->SetColor(0,0,1.0);
   pointSetNode->SetDataInteractor(m_PointSetDataInteractor.GetPointer());
   m_PointSetList.push_back(pointSetNode);
   GetDataStorage()->Add(pointSetNode);
 
 
   m_Controls.m_PostProcessingLayout->hide();
   m_Controls.m_ParameterLayout->hide();
 }
 
 void ClassificationSegmentation::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*source*/,
                                                      const QList<mitk::DataNode::Pointer>& nodes )
 {
   // iterate all selected objects, adjust warning visibility
   foreach( mitk::DataNode::Pointer node, nodes )
   {
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       //      m_Controls.labelWarning->setVisible( false );
       //      m_Controls.buttonPerformImageProcessing->setEnabled( true );
       return;
     }
   }
 
   //  m_Controls.labelWarning->setVisible( true );
   //  m_Controls.buttonPerformImageProcessing->setEnabled( false );
 }
 
 void ClassificationSegmentation::OnAddForestToDataManager()
 {
   AddAsDataNode(m_TempClassifier.GetPointer(),"ManualSegmentation_Classifier");
 }
 
 void ClassificationSegmentation::OnInitializeSession(const mitk::DataNode *)
 {
   MITK_WARN << "Data selection changed! New session initialized.";
 
   m_PointSetDataInteractor->SetDataNode(nullptr);
 
   /// CSF POINTSET
   mitk::PointSet::Pointer pntset = mitk::PointSet::New();
   m_PointSetList[0]->SetData(pntset);
 
   itk::SimpleMemberCommand<ClassificationSegmentation>::Pointer command = itk::SimpleMemberCommand<ClassificationSegmentation>::New();
   command->SetCallbackFunction(this, &ClassificationSegmentation::ManualSegmentationTrigger);
   pntset->AddObserver( mitk::PointSetAddEvent(), command );
   pntset->AddObserver( mitk::PointSetRemoveEvent(), command );
   pntset->AddObserver( mitk::PointSetMoveEvent(), command );
 
   /// LES POINTSET
   pntset = mitk::PointSet::New();
   m_PointSetList[1]->SetData(pntset);
 
   command = itk::SimpleMemberCommand<ClassificationSegmentation>::New();
   command->SetCallbackFunction(this, &ClassificationSegmentation::ManualSegmentationTrigger);
   pntset->AddObserver( mitk::PointSetAddEvent(), command );
   pntset->AddObserver( mitk::PointSetRemoveEvent(), command );
   pntset->AddObserver( mitk::PointSetMoveEvent(), command );
 
   /// BRA POINTSET
   pntset = mitk::PointSet::New();
   m_PointSetList[2]->SetData(pntset);
 
   command = itk::SimpleMemberCommand<ClassificationSegmentation>::New();
   command->SetCallbackFunction(this, &ClassificationSegmentation::ManualSegmentationTrigger);
   pntset->AddObserver( mitk::PointSetAddEvent(), command );
   pntset->AddObserver( mitk::PointSetRemoveEvent(), command );
   pntset->AddObserver( mitk::PointSetMoveEvent(), command );
 
 }
 
 void ClassificationSegmentation::DoSavePointsAsMask()
 {
   mitk::Image::Pointer sampled_image = nullptr;
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_InputImageLayout->itemAt(1)->widget());
   mitk::Image::Pointer raw_image = dynamic_cast<mitk::Image *>(cb_image->GetSelectedNode()->GetData());
 
   int label = 1;
   for( auto datanode : m_PointSetList)
   {
     mitk::PointSet::Pointer point_set = dynamic_cast<mitk::PointSet *>(datanode->GetData());
     mitk::Image::Pointer temp_img;
     SampleClassMaskByPointSet(raw_image, point_set,temp_img);
     mitk::CLUtil::InsertLabel(temp_img,sampled_image,label++);
     QmitkIOUtil::Save(datanode->GetData(),QString("PointSet.mps"));
   }
 
   QmitkIOUtil::Save(sampled_image,QString("PointSetMask.nrrd"));
 }
 void ClassificationSegmentation::ProcessFeatureImages(const mitk::Image::Pointer & raw_image, const mitk::Image::Pointer & brain_mask)
 {
   typedef itk::Image<double,3> DoubleImageType;
   typedef itk::Image<short,3> ShortImageType;
   typedef itk::ConstNeighborhoodIterator<DoubleImageType> NeighborhoodType; // Neighborhood iterator to access image
   typedef itk::Functor::NeighborhoodFirstOrderStatistics<NeighborhoodType, double> FunctorType;
   typedef itk::NeighborhoodFunctorImageFilter<DoubleImageType, DoubleImageType, FunctorType> FOSFilerType;
 
   m_FeatureImageVector.clear();
 
   // RAW
   m_FeatureImageVector.push_back(raw_image);
 
   // GAUSS
   mitk::Image::Pointer smoothed;
   mitk::CLUtil::GaussianFilter(raw_image,smoothed,m_GaussSlider->value());
   m_FeatureImageVector.push_back(smoothed);
 
   // Calculate Probability maps (parameters used from literatur)
   // CSF
   mitk::Image::Pointer csf_prob = mitk::Image::New();
   mitk::CLUtil::ProbabilityMap(smoothed,13.9, 8.3,csf_prob);
   m_FeatureImageVector.push_back(csf_prob);
 
   // Lesion
 
   mitk::Image::Pointer les_prob = mitk::Image::New();
   mitk::CLUtil::ProbabilityMap(smoothed,59, 11.6,les_prob);
   m_FeatureImageVector.push_back(les_prob);
 
   // Barin (GM/WM)
 
   mitk::Image::Pointer brain_prob = mitk::Image::New();
   mitk::CLUtil::ProbabilityMap(smoothed,32, 5.6,brain_prob);
   m_FeatureImageVector.push_back(brain_prob);
 
   std::vector<unsigned int> FOS_sizes;
   FOS_sizes.push_back(1);
 
   DoubleImageType::Pointer input;
   ShortImageType::Pointer mask;
   mitk::CastToItkImage(smoothed, input);
   mitk::CastToItkImage(brain_mask, mask);
 
   for(unsigned int i = 0 ; i < FOS_sizes.size(); i++)
   {
     FOSFilerType::Pointer filter = FOSFilerType::New();
     filter->SetNeighborhoodSize(FOS_sizes[i]);
     filter->SetInput(input);
     filter->SetMask(mask);
 
     filter->Update();
     FOSFilerType::DataObjectPointerArray array = filter->GetOutputs();
 
     for( unsigned int i = 0; i < FunctorType::OutputCount; i++)
     {
       mitk::Image::Pointer featureimage;
       mitk::CastToMitkImage(dynamic_cast<DoubleImageType *>(array[i].GetPointer()),featureimage);
       m_FeatureImageVector.push_back(featureimage);
       //      AddImageAsDataNode(featureimage,FunctorType::GetFeatureName(i))->SetVisibility(show_nodes);
     }
   }
 
   {
     itk::HessianMatrixEigenvalueImageFilter< DoubleImageType >::Pointer filter = itk::HessianMatrixEigenvalueImageFilter< DoubleImageType >::New();
     filter->SetInput(input);
     filter->SetImageMask(mask);
     filter->SetSigma(m_HessianSlider->value());
     filter->Update();
 
     mitk::Image::Pointer o1,o2,o3;
     mitk::CastToMitkImage(filter->GetOutput(0),o1);
     mitk::CastToMitkImage(filter->GetOutput(1),o2);
     mitk::CastToMitkImage(filter->GetOutput(2),o3);
 
     m_FeatureImageVector.push_back(o1);
     m_FeatureImageVector.push_back(o2);
     m_FeatureImageVector.push_back(o3);
 
     //    AddImageAsDataNode(o1,"HE_1")->SetVisibility(show_nodes);
     //    AddImageAsDataNode(o2,"HE_2")->SetVisibility(show_nodes);
     //    AddImageAsDataNode(o3,"HE_3")->SetVisibility(show_nodes);
   }
 
   {
     itk::StructureTensorEigenvalueImageFilter< DoubleImageType >::Pointer filter = itk::StructureTensorEigenvalueImageFilter< DoubleImageType >::New();
     filter->SetInput(input);
     filter->SetImageMask(mask);
     filter->SetInnerScale(m_STInnerSlider->value());
     filter->SetOuterScale(m_STOuterSlider->value());
     filter->Update();
 
     mitk::Image::Pointer o1,o2,o3;
     mitk::CastToMitkImage(filter->GetOutput(0),o1);
     mitk::CastToMitkImage(filter->GetOutput(1),o2);
     mitk::CastToMitkImage(filter->GetOutput(2),o3);
 
     m_FeatureImageVector.push_back(o1);
     m_FeatureImageVector.push_back(o2);
     m_FeatureImageVector.push_back(o3);
 
     //    AddImageAsDataNode(o1,"ST_1")->SetVisibility(show_nodes);
     //    AddImageAsDataNode(o2,"ST_2")->SetVisibility(show_nodes);
     //    AddImageAsDataNode(o3,"ST_3")->SetVisibility(show_nodes);
   }
 
   {
     itk::LineHistogramBasedMassImageFilter< DoubleImageType >::Pointer filter = itk::LineHistogramBasedMassImageFilter< DoubleImageType >::New();
     filter->SetInput(input);
     filter->SetImageMask(mask);
     filter->Update();
 
     mitk::Image::Pointer o1;
     mitk::CastToMitkImage(filter->GetOutput(0),o1);
 
     m_FeatureImageVector.push_back(o1);
   }
 }
 
 void ClassificationSegmentation::OnFeatureSettingsChanged()
 {
   MITK_INFO << "FeatureSettingsChanged";
   m_CalculateFeatures = true;
   ManualSegmentationTrigger();
 }
 
 void ClassificationSegmentation::OnPostProcessingSettingsChanged()
 {
   MITK_INFO << "PostProcessingSettigsChanged";
   PostProcessingTrigger();
 }
 
 void ClassificationSegmentation::DoAutomSegmentation()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_InputImageLayout->itemAt(1)->widget());
   mitk::Image::Pointer raw_image = dynamic_cast<mitk::Image *>(cb_image->GetSelectedNode()->GetData());
   QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_MaskImageLayout->itemAt(1)->widget());
   QmitkDataStorageComboBox * cb_rf = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_ClassifierLayout->itemAt(1)->widget());
 
   mitk::Image::Pointer mask_image = dynamic_cast<mitk::Image *>(cb_maskimage->GetSelectedNode()->GetData());
   mitk::VigraRandomForestClassifier::Pointer classifier = dynamic_cast<mitk::VigraRandomForestClassifier *>(cb_rf->GetSelectedNode()->GetData());
 
   if(m_CalculateFeatures)
   {
     ProcessFeatureImages(raw_image,mask_image);
     m_CalculateFeatures = false;
   }
 
   Eigen::MatrixXd X_test;
 
   unsigned int count_test = 0;
   mitk::CLUtil::CountVoxel(mask_image, count_test);
   X_test = Eigen::MatrixXd(count_test, m_FeatureImageVector.size());
 
   unsigned int index = 0;
   for( const auto & image : m_FeatureImageVector)
   {
     X_test.col(index) = mitk::CLUtil::Transform<double>(image,mask_image);
     ++index;
   }
 
   Eigen::MatrixXi Y_test = classifier->Predict(X_test);
   mitk::Image::Pointer result_mask = mitk::CLUtil::Transform<int>(Y_test,mask_image);
 
   auto node = AddAsDataNode(result_mask.GetPointer(),"Autom-ResultMask");
 
   auto lut = mitk::LookupTable::New();
   lut->SetType(mitk::LookupTable::PET_20);
   auto * lut_prop = dynamic_cast<mitk::LookupTableProperty *>(node->GetProperty("LookupTable"));
   lut_prop->SetLookupTable(lut);
 
   mitk::LevelWindow lw(1,3);
   node->SetLevelWindow(lw);
   node->SetOpacity(0.3);
 
   std::map<unsigned int, unsigned int> perlabelvoxelcount;
   mitk::CLUtil::CountVoxel(result_mask, perlabelvoxelcount);
 
   double voxel_volume = result_mask->GetGeometry()->GetSpacing().GetVnlVector().inf_norm();
   QString newtext;
   newtext += "Name\tVolume\tUnit\n";
   for(const auto & pair: perlabelvoxelcount)
   {
     newtext += "Label" + QString::number(pair.first) + "\t" + QString::number(pair.second*voxel_volume* 0.001) + "\tml\n";
   }
 
   m_Controls.m_ResultTextEdit->setText(newtext);
 }
 
 std::vector<mitk::Image::Pointer> ClassificationSegmentation::ManualSegmentationCallback()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_InputImageLayout->itemAt(1)->widget());
   QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_MaskImageLayout->itemAt(1)->widget());
 
   mitk::Image::Pointer raw_image = dynamic_cast<mitk::Image *>(cb_image->GetSelectedNode()->GetData());
   mitk::Image::Pointer mask_image = dynamic_cast<mitk::Image *>(cb_maskimage->GetSelectedNode()->GetData());
 
   if(raw_image.IsNull() || mask_image.IsNull())
   {
     MITK_WARN << "Please provide input iamge and mask image";
     //return nullptr;
   }
 
   if(m_CalculateFeatures)
   {
     ProcessFeatureImages(raw_image,mask_image);
     m_CalculateFeatures = false;
   }
 
   mitk::Image::Pointer sampled_image = nullptr;
   int label = 1;
   for( auto datanode : m_PointSetList)
   {
     mitk::PointSet::Pointer point_set = dynamic_cast<mitk::PointSet *>(datanode->GetData());
     mitk::Image::Pointer temp_img;
     SampleClassMaskByPointSet(raw_image, point_set,temp_img);
     mitk::CLUtil::InsertLabel(temp_img,sampled_image,label++);
   }
 
   m_TempClassifier = mitk::VigraRandomForestClassifier::New();
   m_TempClassifier->SetTreeCount(50);
   m_TempClassifier->SetSamplesPerTree(0.66);
 
   Eigen::MatrixXd X_train;
   Eigen::MatrixXd X_test;
 
   unsigned int count_train = 0;
   unsigned int count_test = 0;
   mitk::CLUtil::CountVoxel(sampled_image, count_train);
   mitk::CLUtil::CountVoxel(mask_image, count_test);
   X_train = Eigen::MatrixXd(count_train, m_FeatureImageVector.size() );
   X_test = Eigen::MatrixXd(count_test, m_FeatureImageVector.size());
 
   unsigned int index = 0;
   for( const auto & image : m_FeatureImageVector)
   {
     X_train.col(index) = mitk::CLUtil::Transform<double>(image,sampled_image);
     X_test.col(index) = mitk::CLUtil::Transform<double>(image,mask_image);
     ++index;
   }
 
   Eigen::MatrixXi Y = mitk::CLUtil::Transform<int>(sampled_image,sampled_image);
   m_TempClassifier->Train(X_train,Y);
 
   Eigen::MatrixXi Y_test = m_TempClassifier->Predict(X_test);
   Eigen::MatrixXd Yp_test = m_TempClassifier->GetPointWiseProbabilities();
   //  mitk::Image::Pointer result_mask = mitk::CLUtil::Transform<int>(Y_test,mask_image);
 
   std::vector<mitk::Image::Pointer> resultvector;
   resultvector.push_back( mitk::CLUtil::Transform<int>(Y_test,mask_image) );
   resultvector.push_back( mitk::CLUtil::Transform<double>(Yp_test.col(0),mask_image) );
   resultvector.push_back( mitk::CLUtil::Transform<double>(Yp_test.col(1),mask_image) );
   resultvector.push_back( mitk::CLUtil::Transform<double>(Yp_test.col(2),mask_image) );
 
   return resultvector;
 }
 
 void ClassificationSegmentation::ManualSegmentationFinished()
 {
   // Receive Future result
   m_ResultImageVector = m_ManualSegmentationFutureWatcher.result();
 
   // Add result to Datastorage
   mitk::DataNode::Pointer node = AddAsDataNode(m_ResultImageVector[0].GetPointer(),"Manual-ResultMask");
   mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
   lut->SetType(mitk::LookupTable::PET_20);
   mitk::LookupTableProperty * lut_prop = dynamic_cast<mitk::LookupTableProperty *>(node->GetProperty("LookupTable"));
   lut_prop->SetLookupTable(lut);
 
   mitk::LevelWindow lw(1,3);
   node->SetLevelWindow(lw);
   node->SetOpacity(0.3);
 
   m_BlockManualSegmentation = false;
   this->PostProcessingTrigger();
 
   // Update Volume data
   std::map<unsigned int, unsigned int> perlabelvoxelcount;
   mitk::CLUtil::CountVoxel(m_ResultImageVector[0], perlabelvoxelcount);
   double voxel_volume = m_ResultImageVector[0]->GetGeometry()->GetSpacing().GetVnlVector().inf_norm();
   QString newtext;
   newtext += "Name\tVolume\tUnit\n";
   for(const auto & pair: perlabelvoxelcount)
     newtext += "Label" + QString::number(pair.first) + "\t" + QString::number(pair.second*voxel_volume* 0.001) + "\tml\n";
   m_Controls.m_ResultTextEdit->setText(newtext);
 
 
 }
 
 void ClassificationSegmentation::ManualSegmentationTrigger()
 {
   unsigned int samplecounter = 0;
   for( auto datanode : m_PointSetList)
   {
     mitk::PointSet::Pointer point_set = dynamic_cast<mitk::PointSet *>(datanode->GetData());
     samplecounter += point_set->GetSize();
   }
   if(samplecounter < 10) return;
 
   if(!m_BlockManualSegmentation){
     // Start GUI Thread
     m_ManualSegmentationFutureWatcher.setFuture(
           QtConcurrent::run(this, &ClassificationSegmentation::ManualSegmentationCallback)); // on finish call OnManualSegmentationFinished();
     m_BlockManualSegmentation = true;
   }
 }
 
 void ClassificationSegmentation::SampleClassMaskByPointSet(const mitk::Image::Pointer & ref_img, mitk::PointSet::Pointer & pointset, mitk::Image::Pointer & outimage)
 {
   outimage = ref_img->Clone();
   itk::Image<unsigned short, 3>::Pointer itk_out;
   mitk::CastToItkImage(outimage,itk_out);
 
   itk_out->FillBuffer(0);
 
   typedef itk::ImageRegionIteratorWithIndex<itk::Image<unsigned short, 3> > IteratorType;
   IteratorType oit(itk_out, itk_out->GetLargestPossibleRegion());
 
   for(int i = 0 ; i < pointset->GetSize(); ++i)
   {
     IteratorType::IndexType index;
     ref_img->GetGeometry()->WorldToIndex(pointset->GetPoint(i), index);
     oit.SetIndex(index);
     oit.Set(1);
   }
 
   mitk::CastToMitkImage(itk_out,outimage);
 }
 
 // old version
 //void ClassificationSegmentation::DoImageProcessing()
 //{
 //  QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_InputImageLayout->itemAt(1)->widget());
 //  QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_MaskImageLayout->itemAt(1)->widget());
 //  QmitkDataStorageComboBox * cb_classifier = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls.m_RandomForestLayout->itemAt(1)->widget());
 
 //  if (cb_image == nullptr || cb_classifier == nullptr || cb_maskimage == nullptr)
 //  {
 //    QMessageBox::information( nullptr, "Template", "Please load and select an image before starting image processing.");
 //    return;
 //  }
 
 //  mitk::VigraRandomForestClassifier::Pointer rf = dynamic_cast<mitk::VigraRandomForestClassifier *>(cb_classifier->GetSelectedNode()->GetData());
 //  mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(cb_image->GetSelectedNode()->GetData());
 //  mitk::Image::Pointer mask = dynamic_cast<mitk::Image *>(cb_maskimage->GetSelectedNode()->GetData());
 
 //  unsigned int n_samples = 0;
 //  mitk::CLUtil::CountVoxel(mask, n_samples);
 //  unsigned int n_features = 13; // InputImage, PROBA_CSF, PROBA_LES, PROBA_BRA, FOS_MEAN,FOS_VARIANCE,FOS_SKEWNESS, FOS_KURTOSIS, FOS_MIN, FOS_MAX, HE_1, HE_2, HE_3
 
 //  Eigen::MatrixXd feature_matrix = Eigen::MatrixXd(n_samples, n_features);
 
 //  MITK_INFO << "Remove voxels outside the mask";
 //  //  mitk::CLUtil::LogicalAndImages(image,brain_mask,image);
 //  feature_matrix.block(0,0,n_samples,1) = mitk::CLUtil::Transform<double>(image,mask);
 //  AddImageAsDataNode(image, "UI_InputImage");
 
 //  mitk::Image::Pointer csf_prob = mitk::Image::New();
 //  mitk::CLUtil::ProbabilityMap(image,13.9, 8.3,csf_prob);
 //  feature_matrix.block(0,1,n_samples,1) = mitk::CLUtil::Transform<double>(csf_prob,mask);
 //  AddImageAsDataNode(csf_prob, "UI_CSFProb");
 
 //  mitk::Image::Pointer les_prob = mitk::Image::New();
 //  mitk::CLUtil::ProbabilityMap(image,59, 11.6,les_prob);
 //  feature_matrix.block(0,2,n_samples,1) = mitk::CLUtil::Transform<double>(les_prob,mask);
 //  AddImageAsDataNode(les_prob, "UI_LESProb");
 
 //  mitk::Image::Pointer brain_prob = mitk::Image::New();
 //  mitk::CLUtil::ProbabilityMap(image,32, 5.6,brain_prob);
 //  feature_matrix.block(0,3,n_samples,1) = mitk::CLUtil::Transform<double>(brain_prob,mask);
 //  AddImageAsDataNode(brain_prob, "UI_BRAProb");
 
 //  int n = 0;
 
 //  std::vector<mitk::Image::Pointer> res;
 //  DoFirstOrderFeatureCalculation(image, mask, 1, res);
 
 //  for( const auto & img: res)
 //  {
 //    feature_matrix.block(0,3+(++n),n_samples,1) = mitk::CLUtil::Transform<double>(img,mask);
 //    std::string name;
 //    img->GetPropertyList()->GetStringProperty("name", name);
 //    AddImageAsDataNode(img.GetPointer(), name );
 //  }
 
 //  res.clear();
 //  DoHessianEigenvaluesFeatureCalculation(image, mask, 3.0, res);
 //  for( const auto & img: res)
 //  {
 //    feature_matrix.block(0,3+(++n),n_samples,1) = mitk::CLUtil::Transform<double>(img,mask);
 //    std::string name;
 //    img->GetPropertyList()->GetStringProperty("name", name);
 //    AddImageAsDataNode(img.GetPointer(), name );
 //  }
 
 //  MITK_INFO << "Start Prediction";
 //  rf->Predict(feature_matrix);
 //  MITK_INFO << "End Prediction";
 
 //  mitk::Image::Pointer result_image = mitk::CLUtil::Transform<int>(rf->GetLabels(),mask);
 //  mitk::Image::Pointer proba1_image = mitk::CLUtil::Transform<double>(rf->GetPointWiseProbabilities().col(0),mask);
 //  mitk::Image::Pointer proba2_image = mitk::CLUtil::Transform<double>(rf->GetPointWiseProbabilities().col(1),mask);
 //  mitk::Image::Pointer proba3_image = mitk::CLUtil::Transform<double>(rf->GetPointWiseProbabilities().col(2),mask);
 
 //  AddImageAsDataNode(result_image, "ClassificationResult");
 //  AddImageAsDataNode(proba1_image, "CSF_Proba_CL");
 //  AddImageAsDataNode(proba2_image, "LES_Proba_CL");
 //  AddImageAsDataNode(proba3_image, "BRA_Proba_CL");
 
 //  PostProcessing(rf,mask);
 
 //}
 
 mitk::DataNode::Pointer ClassificationSegmentation::AddAsDataNode(const mitk::BaseData::Pointer & data_, const std::string & name )
 {
   mitk::DataNode::Pointer node = nullptr;
   node = this->GetDataStorage()->GetNamedNode(name);
 
   if(node.IsNull())
   {
     node = mitk::DataNode::New();
     node->SetData(data_);
     node->SetName(name);
     this->GetDataStorage()->Add(node);
   }else{
 
     if(dynamic_cast<mitk::Image*>(node->GetData()) && dynamic_cast<mitk::Image*>(data_.GetPointer()))
     {
       mitk::Image::Pointer target_image = dynamic_cast<mitk::Image*>(node->GetData());
       mitk::Image::Pointer source_image = dynamic_cast<mitk::Image*>(data_.GetPointer());
       mitk::ImageReadAccessor ra(source_image);
       target_image->SetImportVolume(const_cast<void *>(ra.GetData()));
       this->RequestRenderWindowUpdate();
     }
 
     if(dynamic_cast<mitk::VigraRandomForestClassifier*>(node->GetData()) && dynamic_cast<mitk::VigraRandomForestClassifier*>(data_.GetPointer()))
     {
       node->SetData(data_);
       node->Modified();
     }
 
   }
 
   return node;
 }
 
 void ClassificationSegmentation::PostProcessingTrigger()
 {
   if(m_ResultImageVector.empty() || m_ResultImageVector.size() < 4)
   {
     MITK_ERROR("PostProcessingCallback") << "Result image vector not initialized!";
     return;
   }
 
   if(!m_BlockPostProcessing){
     m_PostProcessingFutureWatcher.setFuture(
           QtConcurrent::run(this, &ClassificationSegmentation::PostProcessingCallback)); // on finish call OnManualSegmentationFinished();
     m_BlockPostProcessing = true;
   }
 }
 
 void ClassificationSegmentation::PostProcessingFinished()
 {
   // Receive Future result
   m_PostProcessingImageVector = m_PostProcessingFutureWatcher.result();
 
   // Add result to Datastorage
   mitk::DataNode::Pointer node = AddAsDataNode(m_PostProcessingImageVector[0].GetPointer(),"Manual-ResultMask-PostProcessing");
   mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
   lut->SetType(mitk::LookupTable::PET_20);
   mitk::LookupTableProperty * lut_prop = dynamic_cast<mitk::LookupTableProperty *>(node->GetProperty("LookupTable"));
   lut_prop->SetLookupTable(lut);
 
   mitk::LevelWindow lw(1,3);
   node->SetLevelWindow(lw);
   node->SetOpacity(0.3);
 
   m_BlockPostProcessing = false;
 }
 
 std::vector<mitk::Image::Pointer> ClassificationSegmentation::PostProcessingCallback()
 {
   std::vector<mitk::Image::Pointer> resultvector;
 
   mitk::Image::Pointer CSF_PMap = m_ResultImageVector[1]->Clone();
   mitk::Image::Pointer LES_PMap = m_ResultImageVector[2]->Clone();
   mitk::Image::Pointer BRA_PMap = m_ResultImageVector[3]->Clone();
   mitk::Image::Pointer mask = m_ResultImageVector[0]->Clone();
 
   MITK_INFO("PostProcessingCallback") << "ProbabilityMap merg strat ...";
 
   {
     mitk::Image::Pointer resultmask = mask->Clone();
     mitk::CLUtil::GaussianFilter(CSF_PMap, CSF_PMap, m_GaussCSFSlider->value());
     mitk::CLUtil::GaussianFilter(LES_PMap, LES_PMap, m_GaussLESSlider->value());
     mitk::CLUtil::GaussianFilter(BRA_PMap, BRA_PMap, m_GaussBRASlider->value());
 
     itk::Image<double, 3>::Pointer itk_csf, itk_les, itk_bra;
     itk::Image<unsigned char, 3>::Pointer itk_result;
 
     mitk::CastToItkImage(CSF_PMap, itk_csf);
     mitk::CastToItkImage(LES_PMap, itk_les);
     mitk::CastToItkImage(BRA_PMap, itk_bra);
     mitk::CastToItkImage(resultmask, itk_result);
 
     itk::ImageRegionIterator<itk::Image<double, 3> > it_csf(itk_csf,itk_csf->GetLargestPossibleRegion());
     itk::ImageRegionIterator<itk::Image<double, 3> > it_les(itk_les,itk_les->GetLargestPossibleRegion());
     itk::ImageRegionIterator<itk::Image<double, 3> > it_bra(itk_bra,itk_bra->GetLargestPossibleRegion());
     itk::ImageRegionIterator<itk::Image<unsigned char, 3> > it_res(itk_result,itk_result->GetLargestPossibleRegion());
 
     while (!it_csf.IsAtEnd()) {
       double csf = it_csf.Value() * m_WeightCSFSlider->value();
       double les = it_les.Value() * m_WeightLESSlider->value();
       double bra = it_bra.Value() * m_WeightBRASlider->value();
 
       if(csf > les && csf > bra) it_res.Set(1);
       if(les > csf && les > bra) it_res.Set(2);
       if(bra > les && bra > csf) it_res.Set(3);
 
       ++it_csf;
       ++it_les;
       ++it_bra;
       ++it_res;
     }
 
     mitk::CastToMitkImage(itk_result, resultmask);
 
     {
       std::map<unsigned int, unsigned int> mergeinstruction ;
       mergeinstruction[1] = 1;
       mergeinstruction[2] = 1;
       mergeinstruction[3] = 1;
       mergeinstruction[4] = 1;
       mergeinstruction[5] = 1;
       mergeinstruction[6] = 1;
 
       // {{1,1},{2,1},{3,1},{4,1},{5,1},{6,1}};
       mitk::Image::Pointer brain_mask = mask->Clone();
       mitk::CLUtil::MergeLabels(brain_mask, mergeinstruction);
       mitk::CLUtil::ClosingBinary(brain_mask,brain_mask,2,mitk::CLUtil::All);
       mitk::CLUtil::LogicalAndImages(resultmask, brain_mask, resultmask);
     }
     MITK_INFO("PostProcessingCallback") << "ProbabilityMap merg end!";
 
     resultvector.push_back(resultmask);
   }
 
   return resultvector;
 
   //  {
   //    MITK_INFO << "Morphological processing strat ...";
   //    mitk::Image::Pointer resultmask =  mask->Clone();
 
   //    mitk::Image::Pointer csf_mask;
   //    mitk::CLUtil::GrabLabel(resultmask, csf_mask, 1);
   //    mitk::CLUtil::ClosingBinary(csf_mask,csf_mask,1,mitk::CLUtil::Axial);
 
   //    mitk::CLUtil::ErodeBinary(csf_mask, csf_mask, 2, mitk::CLUtil::Axial);
   //    mitk::CLUtil::DilateBinary(csf_mask, csf_mask, 1, mitk::CLUtil::Axial);
 
   //    std::map<unsigned int, unsigned int> merge_instruction = {{0,0},{1,3},{2,2},{3,3}};
   //    mitk::CLUtil::MergeLabels(resultmask, merge_instruction);
 
   //    mitk::CLUtil::InsertLabel(resultmask, csf_mask, 1/*as csf mask*/); // add morpological manipulated csf_mask
 
   //    // ------------
 
   //    mitk::Image::Pointer les_mask;
   //    mitk::CLUtil::GrabLabel(resultmask, les_mask, 2);
   //    mitk::CLUtil::ClosingBinary(les_mask,les_mask,1,mitk::CLUtil::Axial);
 
   //    mitk::Image::Pointer les_cc_mask; unsigned int num = 0;
   //    mitk::CLUtil::ConnectedComponentsImage(les_mask, mask, les_cc_mask, num);
   //    std::map<unsigned int, unsigned int> map;
   //    mitk::CLUtil::CountVoxel(les_cc_mask,map);
   //    unsigned int counter = 0;
 
   //    while(map.size() > 2)
   //    {
   //      mitk::CLUtil::ErodeBinary(les_mask, les_mask, 1, mitk::CLUtil::Axial);
   //      mitk::CLUtil::LogicalAndImages(les_cc_mask,les_mask,les_cc_mask);
   //      map.clear();
   //      mitk::CLUtil::CountVoxel(les_cc_mask,map);
   //      MITK_INFO("PostProcessing") << map.size();
   //      counter++;
   //    }
 
   //    while(counter != 0)
   //    {
   //      mitk::CLUtil::DilateBinary(les_mask, les_mask, 1, mitk::CLUtil::Axial);
   //      counter--;
   //    }
 
   //    merge_instruction = {{0,0},{1,1},{2,3},{3,3}};
   //    mitk::CLUtil::MergeLabels(resultmask, merge_instruction);
   //    mitk::CLUtil::InsertLabel(resultmask, les_mask, 2/*as les mask*/);
 
   //    MITK_INFO << "Morphological processing end";
 
   //    // ------------
   //    mitk::CLUtil::LogicalAndImages(resultmask,mask,resultmask);
 
   //    AddImageAsDataNode(resultmask,"SmoothedMaskMorphed");
 
   //  }
 }
 
 //  mitk::Image::Pointer r= mitk::Image::New(),g= mitk::Image::New(),b = mitk::Image::New();
 
 //     unsigned int* m_ImageDimensions;
 //     m_ImageDimensions = new unsigned int[3];
 //     m_ImageDimensions[0] = raw_image->GetDimensions()[0];
 //     m_ImageDimensions[1] = raw_image->GetDimensions()[1];
 //     m_ImageDimensions[2] = 1;
 
 //     r->Initialize( mitk::MakePixelType<unsigned char,unsigned char,1>() ,3,m_ImageDimensions);
 //     g->Initialize( mitk::MakePixelType<unsigned char,unsigned char,1>() ,3,m_ImageDimensions);
 //     b->Initialize( mitk::MakePixelType<unsigned char,unsigned char,1>() ,3,m_ImageDimensions);
 
 //     mitk::ImageReadAccessor inputAccForRGB(raw_image, raw_image->GetSliceData(0,0,0));
 //     unsigned char* rbgSlice = (unsigned char*)inputAccForRGB.GetData();
 
 //     mitk::ImageReadAccessor inputAcc(r, r->GetSliceData(0,0,0));
 //     unsigned char* rData = (unsigned char*)inputAcc.GetData();
 
 //     mitk::ImageReadAccessor inputAcc2(g, g->GetSliceData(0,0,0));
 //     unsigned char* gData = (unsigned char*)inputAcc2.GetData();
 
 //     mitk::ImageReadAccessor inputAcc3(b, b->GetSliceData(0,0,0));
 //     unsigned char*
 //         bData = (unsigned char*)inputAcc3.GetData();
 
 //     for(int i = 0; i <  m_ImageDimensions[0] * m_ImageDimensions[1]*3; i+=3)
 //     {
 //       rData[i/3] = rbgSlice[i];
 //       gData[i/3] = rbgSlice[i+1];
 //       bData[i/3] = rbgSlice[i+2];
 
 //     }
 
 //  m_FeatureImageVector.push_back(r);
 //  m_FeatureImageVector.push_back(g);
 //  m_FeatureImageVector.push_back(b);
 
 //  AddImageAsDataNode(r,"r");
 //  AddImageAsDataNode(g,"g");
 //  AddImageAsDataNode(b,"b");
diff --git a/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationSegmentation.h b/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationSegmentation.h
index 3fce603c7d..5894d95171 100644
--- a/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationSegmentation.h
+++ b/Plugins/org.mitk.gui.qt.classificationsegmentation/src/internal/ClassificationSegmentation.h
@@ -1,141 +1,134 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef ClassificationSegmentation_h
 #define ClassificationSegmentation_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_ClassificationSegmentationControls.h"
 #include <mitkImage.h>
 #include <itkConstNeighborhoodIterator.h>
 #include <itkNeighborhoodFunctorImageFilter.h>
 #include <itkFirstOrderStatisticsFeatureFunctor.h>
 
 #include <mitkImageCast.h>
 #include <vigra/tensorutilities.hxx>
 #include <vigra/convolution.hxx>
 #include <vigra/multi_array.hxx>
 #include <mitkPointSet.h>
 #include <itkHistogram.h>
 #include <QFutureWatcher>
-#include "QmitkPointListViewWidget.h"
 #include <mitkPointSetDataInteractor.h>
 
 #include <mitkVigraRandomForestClassifier.h>
 /**
 \brief ClassificationSegmentation
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
 \sa QmitkAbstractView
 \ingroup ${plugin_target}_internal
 */
 
-
-//class QmitkPointListWidget;
 class ctkSliderWidget;
 class ClassificationSegmentation : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
-  QmitkPointListViewWidget * m_PointListWidget;
   std::vector<mitk::DataNode::Pointer> m_PointSetList;
   bool m_CalculateFeatures;
 
   std::vector<mitk::Image::Pointer> m_FeatureImageVector;
   std::vector<mitk::Image::Pointer> m_ResultImageVector;
   std::vector<mitk::Image::Pointer> m_PostProcessingImageVector;
 
   bool m_BlockManualSegmentation;
   QFutureWatcher<std::vector<mitk::Image::Pointer>> m_ManualSegmentationFutureWatcher;
 
   bool m_BlockPostProcessing;
   QFutureWatcher<std::vector<mitk::Image::Pointer>> m_PostProcessingFutureWatcher;
 
   protected slots:
 
     /// \brief Called when the user clicks the GUI button
     void DoAutomSegmentation();
     void DoSavePointsAsMask();
     void OnButtonCSFToggle(bool);
     void OnButtonLESToggle(bool);
     void OnButtonBRAToggle(bool);
     void OnButtonNoInteractionToggle(bool);
     void OnAddForestToDataManager();
 
     void ManualSegmentationTrigger();
     std::vector<mitk::Image::Pointer> ManualSegmentationCallback();
     void ManualSegmentationFinished();
 
     void PostProcessingTrigger();
     std::vector<mitk::Image::Pointer> PostProcessingCallback();
     void PostProcessingFinished();
 
     void OnFeatureSettingsChanged();
     void OnPostProcessingSettingsChanged();
     void OnInitializeSession(const mitk::DataNode*);
 
 protected:
 
   typedef float MeasurementType;
   typedef itk::Statistics::Histogram< MeasurementType,
     itk::Statistics::DenseFrequencyContainer2 > HistogramType;
 
   //  void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart);
   //  void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart);
 
   void CreateQtPartControl(QWidget *parent) override;
 
   void SetFocus() override;
 
   mitk::DataNode::Pointer AddAsDataNode(const mitk::BaseData::Pointer & data_, const std::string & name );
 
   void SampleClassMaskByPointSet(const mitk::Image::Pointer & ref_img, mitk::PointSet::Pointer & pointset, mitk::Image::Pointer & outimage);
 
   void ProcessFeatureImages(const mitk::Image::Pointer & raw_image, const mitk::Image::Pointer & mask_image);
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
   void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
     const QList<mitk::DataNode::Pointer>& nodes ) override;
 
   mitk::Image::Pointer CreateClassMaskByPointsetList(std::map<unsigned int, mitk::PointSet *> a_args);
 
   Ui::ClassificationSegmentationControls m_Controls;
 
   // Feature settings
   ctkSliderWidget * m_GaussSlider;
   ctkSliderWidget * m_HessianSlider;
   ctkSliderWidget * m_STInnerSlider;
   ctkSliderWidget * m_STOuterSlider;
 
   ctkSliderWidget * m_GaussCSFSlider;
   ctkSliderWidget * m_GaussLESSlider;
   ctkSliderWidget * m_GaussBRASlider;
 
   ctkSliderWidget * m_WeightCSFSlider;
   ctkSliderWidget * m_WeightLESSlider;
   ctkSliderWidget * m_WeightBRASlider;
 
   mitk::PointSetDataInteractor::Pointer m_PointSetDataInteractor;
   mitk::VigraRandomForestClassifier::Pointer m_TempClassifier;
 };
 
 #endif // ClassificationSegmentation_h
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/CMakeLists.txt b/Plugins/org.mitk.gui.qt.common.legacy/CMakeLists.txt
deleted file mode 100755
index 50b2016664..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/CMakeLists.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-project(org_mitk_gui_qt_common_legacy)
-
-mitk_create_plugin(
-  EXPORT_DIRECTIVE MITK_QT_COMMON_LEGACY
-  EXPORTED_INCLUDE_SUFFIXES src
-  MODULE_DEPENDS MitkQtWidgets
-  )
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.common.legacy/documentation/doxygen/modules.dox
deleted file mode 100755
index bd669c5afb..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/documentation/doxygen/modules.dox
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
-  \defgroup org_mitk_gui_qt_common_legacy org.mitk.gui.qt.common.legacy
-  \ingroup MITKPlugins
-
-  \brief Provides legacy classes and functionality common for MITK plug-ins.
-
-  \deprecated This plug-in is deprecated. Old plug-ins having a dependency on it should
-              migrate to the org_mitk_gui_qt_common Plug-in using https://www.mitk.org/wiki/Views_Without_Multi_Widget
-
-*/
-
-/**
-  \defgroup org_mitk_gui_qt_common_legacy_internal Internal
-  \ingroup org_mitk_gui_qt_common_legacy
-
-  \brief This subcategory includes the internal classes of the org.mitk.gui.qt.common.legacy plugin. Other
-  plugins must not rely on these classes. They contain implementation details and their interface
-  may change at any time. We mean it.
-*/
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/files.cmake b/Plugins/org.mitk.gui.qt.common.legacy/files.cmake
deleted file mode 100755
index 331c6b063f..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/files.cmake
+++ /dev/null
@@ -1,33 +0,0 @@
-set(SRC_CPP_FILES
-  QmitkFunctionality.cpp
-  QmitkFunctionality2.cpp
-  QmitkFunctionalityCoordinator.cpp
-)
-
-set(INTERNAL_CPP_FILES
-  QmitkCommonLegacyActivator.cpp
-  QmitkFunctionalityUtil.cpp
-)
-
-set(MOC_H_FILES
-  src/internal/QmitkCommonLegacyActivator.h
-)
-
-set(UI_FILES
-)
-
-set(CACHED_RESOURCE_FILES
-)
-
-set(QRC_FILES
-)
-
-set(CPP_FILES )
-
-foreach(file ${SRC_CPP_FILES})
-  set(CPP_FILES ${CPP_FILES} src/${file})
-endforeach(file ${SRC_CPP_FILES})
-
-foreach(file ${INTERNAL_CPP_FILES})
-  set(CPP_FILES ${CPP_FILES} src/internal/${file})
-endforeach(file ${INTERNAL_CPP_FILES})
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.common.legacy/manifest_headers.cmake
deleted file mode 100644
index 525768d803..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/manifest_headers.cmake
+++ /dev/null
@@ -1,6 +0,0 @@
-set(Plugin-Name "Legacy Plug-in for QmitkStdMultiWidgetEditor")
-set(Plugin-Version "1.0.0")
-set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
-set(Plugin-ContactAddress "http://www.mitk.org")
-set(Require-Plugin org.mitk.gui.qt.stdmultiwidgeteditor)
-
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.cpp b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.cpp
deleted file mode 100644
index a18f8f3b53..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.cpp
+++ /dev/null
@@ -1,373 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include "QmitkFunctionality.h"
-#include "internal/QmitkFunctionalityUtil.h"
-#include "internal/QmitkCommonLegacyActivator.h"
-
-// other includes
-#include <mitkLogMacros.h>
-
-// mitk Includes
-#include <mitkIDataStorageService.h>
-#include <mitkDataStorageEditorInput.h>
-
-// berry Includes
-#include <berryIWorkbenchPage.h>
-#include <berryIBerryPreferences.h>
-#include <berryIEditorPart.h>
-#include <berryPlatform.h>
-
-// Qmitk Includes
-#include <QmitkStdMultiWidgetEditor.h>
-
-// Qt Includes
-#include <QMessageBox>
-#include <QScrollArea>
-#include <QVBoxLayout>
-#include <QApplication>
-
-QmitkFunctionality::QmitkFunctionality()
- : m_Parent(nullptr)
- , m_Active(false)
- , m_Visible(false)
- , m_SelectionProvider(nullptr)
- , m_DataStorageServiceTracker(QmitkCommonLegacyActivator::GetContext())
- , m_HandlesMultipleDataStorages(false)
- , m_InDataStorageChanged(false)
-{
-  m_DataStorageServiceTracker.open();
-}
-
-void QmitkFunctionality::SetHandleMultipleDataStorages(bool multiple)
-{
-  m_HandlesMultipleDataStorages = multiple;
-}
-
-bool QmitkFunctionality::HandlesMultipleDataStorages() const
-{
-  return m_HandlesMultipleDataStorages;
-}
-
-mitk::DataStorage::Pointer
-QmitkFunctionality::GetDataStorage() const
-{
-  mitk::IDataStorageService* service = m_DataStorageServiceTracker.getService();
-
-  if (service != nullptr)
-  {
-    if(m_HandlesMultipleDataStorages)
-      return service->GetActiveDataStorage()->GetDataStorage();
-    else
-      return service->GetDefaultDataStorage()->GetDataStorage();
-  }
-
-  return nullptr;
-}
-
-mitk::DataStorage::Pointer QmitkFunctionality::GetDefaultDataStorage() const
-{
-  mitk::IDataStorageService* service = m_DataStorageServiceTracker.getService();
-
-  if (service != nullptr)
-  {
-    return service->GetDefaultDataStorage()->GetDataStorage();
-  }
-
-  return nullptr;
-}
-
-mitk::IDataStorageReference::Pointer QmitkFunctionality::GetDataStorageReference() const
-{
-  mitk::IDataStorageService* dsService = m_DataStorageServiceTracker.getService();
-
-  if (dsService != nullptr)
-  {
-    return dsService->GetDataStorage();
-  }
-
-  return mitk::IDataStorageReference::Pointer(nullptr);
-}
-
-void QmitkFunctionality::CreatePartControl(QWidget* parent)
-{
-
-  // scrollArea
-  QScrollArea* scrollArea = new QScrollArea;
-  //QVBoxLayout* scrollAreaLayout = new QVBoxLayout(scrollArea);
-  scrollArea->setFrameShadow(QFrame::Plain);
-  scrollArea->setFrameShape(QFrame::NoFrame);
-  scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
-  scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
-
-  // m_Parent
-  m_Parent = new QWidget;
-  //m_Parent->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
-  this->CreateQtPartControl(m_Parent);
-
-  //scrollAreaLayout->addWidget(m_Parent);
-  //scrollArea->setLayout(scrollAreaLayout);
-
-  // set the widget now
-  scrollArea->setWidgetResizable(true);
-  scrollArea->setWidget(m_Parent);
-
-  // add the scroll area to the real parent (the view tabbar)
-  QWidget* parentQWidget = static_cast<QWidget*>(parent);
-  QVBoxLayout* parentLayout = new QVBoxLayout(parentQWidget);
-  parentLayout->setMargin(0);
-  parentLayout->setSpacing(0);
-  parentLayout->addWidget(scrollArea);
-
-  // finally set the layout containing the scroll area to the parent widget (= show it)
-  parentQWidget->setLayout(parentLayout);
-
-  this->AfterCreateQtPartControl();
-}
-
-void QmitkFunctionality::AfterCreateQtPartControl()
-{
-  // REGISTER DATASTORAGE LISTENER
-  this->GetDefaultDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
-    ( this, &QmitkFunctionality::NodeAddedProxy ) );
-  this->GetDefaultDataStorage()->ChangedNodeEvent.AddListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
-    ( this, &QmitkFunctionality::NodeChangedProxy ) );
-  this->GetDefaultDataStorage()->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
-    ( this, &QmitkFunctionality::NodeRemovedProxy ) );
-
-  // REGISTER PREFERENCES LISTENER
-  berry::IBerryPreferences::Pointer prefs = this->GetPreferences().Cast<berry::IBerryPreferences>();
-  if(prefs.IsNotNull())
-    prefs->OnChanged.AddListener(berry::MessageDelegate1<QmitkFunctionality
-    , const berry::IBerryPreferences*>(this, &QmitkFunctionality::OnPreferencesChanged));
-
-  // REGISTER FOR WORKBENCH SELECTION EVENTS
-  m_BlueBerrySelectionListener.reset(new berry::SelectionChangedAdapter<QmitkFunctionality>(
-                                       this,
-                                       &QmitkFunctionality::BlueBerrySelectionChanged)
-                                     );
-  this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(
-        /*"org.mitk.views.datamanager",*/ m_BlueBerrySelectionListener.data());
-
-  // REGISTER A SELECTION PROVIDER
-  QmitkFunctionalitySelectionProvider::Pointer _SelectionProvider(
-        new QmitkFunctionalitySelectionProvider(this));
-  m_SelectionProvider = _SelectionProvider.GetPointer();
-  this->GetSite()->SetSelectionProvider(berry::ISelectionProvider::Pointer(m_SelectionProvider));
-
-  // EMULATE INITIAL SELECTION EVENTS
-
-  // by default a multi widget is always available
-  this->MultiWidgetAvailable(*this->GetActiveMultiWidget());
-
-  // send datamanager selection
-  this->OnSelectionChanged(this->GetDataManagerSelection());
-
-  // send preferences changed event
-  this->OnPreferencesChanged(this->GetPreferences().Cast<berry::IBerryPreferences>().GetPointer());
-}
-
-void QmitkFunctionality::ClosePart()
-{
-
-}
-
-void QmitkFunctionality::ClosePartProxy()
-{
-  this->GetDefaultDataStorage()->AddNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
-    ( this, &QmitkFunctionality::NodeAddedProxy ) );
-  this->GetDefaultDataStorage()->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
-    ( this, &QmitkFunctionality::NodeRemovedProxy) );
-  this->GetDefaultDataStorage()->ChangedNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
-    ( this, &QmitkFunctionality::NodeChangedProxy ) );
-
-  berry::IBerryPreferences::Pointer prefs = this->GetPreferences().Cast<berry::IBerryPreferences>();
-  if(prefs.IsNotNull())
-  {
-    prefs->OnChanged.RemoveListener(berry::MessageDelegate1<QmitkFunctionality
-    , const berry::IBerryPreferences*>(this, &QmitkFunctionality::OnPreferencesChanged));
-    // flush the preferences here (disabled, everyone should flush them by themselves at the right moment)
-    // prefs->Flush();
-  }
-
-  // REMOVE SELECTION PROVIDER
-  this->GetSite()->SetSelectionProvider(berry::ISelectionProvider::Pointer(nullptr));
-
-  berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
-  if(s)
-  {
-    s->RemovePostSelectionListener(m_BlueBerrySelectionListener.data());
-  }
-
-  this->ClosePart();
-}
-
-QmitkFunctionality::~QmitkFunctionality()
-{
-  this->Register();
-  this->ClosePartProxy();
-
-  this->UnRegister(false);
-
-  m_DataStorageServiceTracker.close();
-}
-
-void QmitkFunctionality::OnPreferencesChanged( const berry::IBerryPreferences* )
-{
-}
-
-void QmitkFunctionality::BlueBerrySelectionChanged(const berry::IWorkbenchPart::Pointer& sourcepart,
-                                                   const berry::ISelection::ConstPointer& selection)
-{
-  if(sourcepart.IsNull() || sourcepart->GetSite()->GetId() != "org.mitk.views.datamanager")
-    return;
-
-  mitk::DataNodeSelection::ConstPointer _DataNodeSelection
-    = selection.Cast<const mitk::DataNodeSelection>();
-  this->OnSelectionChanged(this->DataNodeSelectionToVector(_DataNodeSelection));
-}
-
-bool QmitkFunctionality::IsVisible() const
-{
-  return m_Visible;
-}
-
-void QmitkFunctionality::SetFocus()
-{
-}
-
-void QmitkFunctionality::Activated()
-{
-}
-
-void QmitkFunctionality::Deactivated()
-{
-}
-
-void QmitkFunctionality::MultiWidgetAvailable( QmitkAbstractMultiWidget&  /*multiWidget*/ )
-{
-}
-void QmitkFunctionality::MultiWidgetNotAvailable()
-{
-}
-
-void QmitkFunctionality::DataStorageChanged()
-{
-
-}
-
-QmitkAbstractMultiWidget* QmitkFunctionality::GetActiveMultiWidget( bool reCreateWidget )
-{
-  QmitkAbstractMultiWidget* activeMultiWidget = nullptr;
-
-  berry::IEditorPart::Pointer editor =
-    this->GetSite()->GetPage()->GetActiveEditor();
-
-  if (reCreateWidget || editor.Cast<QmitkStdMultiWidgetEditor>().IsNull())
-  {
-    mitk::DataStorageEditorInput::Pointer editorInput(
-          new mitk::DataStorageEditorInput( this->GetDataStorageReference() ));
-    // open a new multi-widget editor, but do not give it the focus
-    berry::IEditorPart::Pointer editor = this->GetSite()->GetPage()->OpenEditor(editorInput, QmitkStdMultiWidgetEditor::EDITOR_ID, false, berry::IWorkbenchPage::MATCH_ID);
-    activeMultiWidget = editor.Cast<QmitkStdMultiWidgetEditor>()->GetMultiWidget();
-  }
-  else if (editor.Cast<QmitkStdMultiWidgetEditor>().IsNotNull())
-  {
-    activeMultiWidget = editor.Cast<QmitkStdMultiWidgetEditor>()->GetMultiWidget();
-  }
-
-  return activeMultiWidget;
-}
-
-void QmitkFunctionality::HandleException( const char* str, QWidget* parent, bool showDialog ) const
-{
-  //itkGenericOutputMacro( << "Exception caught: " << str );
-  MITK_ERROR << str;
-  if ( showDialog )
-  {
-    QMessageBox::critical ( parent, "Exception caught!", str );
-  }
-}
-
-void QmitkFunctionality::HandleException( std::exception& e, QWidget* parent, bool showDialog ) const
-{
-  HandleException( e.what(), parent, showDialog );
-}
-
-void QmitkFunctionality::MultiWidgetClosed( QmitkAbstractMultiWidget&  /*multiWidget*/ )
-{
-
-}
-
-void QmitkFunctionality::WaitCursorOn()
-{
-  QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
-}
-
-void QmitkFunctionality::BusyCursorOn()
-{
-  QApplication::setOverrideCursor( QCursor(Qt::BusyCursor) );
-}
-
-void QmitkFunctionality::WaitCursorOff()
-{
-  this->RestoreOverrideCursor();
-}
-
-void QmitkFunctionality::BusyCursorOff()
-{
-  this->RestoreOverrideCursor();
-}
-
-void QmitkFunctionality::RestoreOverrideCursor()
-{
-  QApplication::restoreOverrideCursor();
-}
-
-berry::IPreferences::Pointer QmitkFunctionality::GetPreferences() const
-{
-  berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
-  // const_cast workaround for bad programming: const uncorrectness this->GetViewSite() should be const
-  QString id = "/" + (const_cast<QmitkFunctionality*>(this))->GetViewSite()->GetId();
-  return prefService != nullptr ? prefService->GetSystemPreferences()->Node(id): berry::IPreferences::Pointer(nullptr);
-}
-
-void QmitkFunctionality::Visible()
-{
-
-}
-
-void QmitkFunctionality::Hidden()
-{
-
-}
-
-bool QmitkFunctionality::IsExclusiveFunctionality() const
-{
-  return true;
-}
-
-void QmitkFunctionality::SetVisible( bool visible )
-{
-  m_Visible = visible;
-}
-
-void QmitkFunctionality::SetActivated( bool activated )
-{
-  m_Active = activated;
-}
-
-bool QmitkFunctionality::IsActivated() const
-{
-  return m_Active;
-}
-
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.h b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.h
deleted file mode 100755
index fae0b394ce..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.h
+++ /dev/null
@@ -1,397 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#ifndef QMITKFUNCTIONALITY_H_
-#define QMITKFUNCTIONALITY_H_
-
-//# blueberry stuff
-#include <berryQtViewPart.h>
-#include <berryIPreferencesService.h>
-#include <berryISelectionListener.h>
-
-#include <berryIPreferences.h>
-
-//# mitk stuff
-#include <org_mitk_gui_qt_common_legacy_Export.h>
-#include "mitkDataNodeSelection.h"
-#include <mitkDataStorage.h>
-#include <mitkIDataStorageService.h>
-#include <mitkIDataStorageReference.h>
-#include <QmitkAbstractMultiWidget.h>
-
-// CTK Includes
-#include <ctkServiceTracker.h>
-
-
-//# forward declarations
-
-namespace mitk {
-  class DataNode;
-  struct IDataStorageService;
-}
-
-namespace berry {
-  struct IBerryPreferences;
-}
-
-class QmitkFunctionalitySelectionProvider;
-
-///
-/// \ingroup org_mitk_gui_qt_common_legacy
-///
-/// \class QmitkFunctionality
-///
-/// \brief The base class of all MITK related blueberry views (~ in the old version of MITK, this was called "Functionality")
-///
-/// QmitkFunctionality provides several convenience methods that eases the introduction of a new view:
-///
-/// <ol>
-///   <li> Access to the DataStorage (~ the shared data repository)
-///   <li> Access to the MultiWidget
-///   <li> Access to and update notification for the functionality/view preferences
-///   <li> Access to and update notification for the current DataNode selection / to DataNode selection events send through the SelectionService
-///   <li> Methods to send DataNode selections through the SelectionService
-///   <li> Some events for unproblematic inter-View communication (e.g. when to add/remove interactors)
-///   <li> Some minor important convenience methods (like changing the mouse cursor/exception handling)
-/// </ol>
-///
-/// Please use the Activated/Deactivated method to add/remove interactors, disabling multiwidget crosshair or anything which may
-/// "affect" other functionalities. For further reading please have a look at QmitkFunctionality::IsExclusiveFunctionality().
-///
-class MITK_QT_COMMON_LEGACY QmitkFunctionality : public berry::QtViewPart
-{
-
-//# public virtual methods which can be overwritten
-public:
-  ///
-  /// Creates smartpointer typedefs
-  ///
-  berryObjectMacro(QmitkFunctionality);
-  ///
-  /// Nothing to do in the standard ctor. <b>Initiliaze your GUI in CreateQtPartControl(QWidget*)</b>
-  /// \see berry::QtViewPart::CreateQtPartControl(QWidget*)
-  ///
-  QmitkFunctionality();
-  ///
-  /// Disconnects all standard event listeners
-  ///
-  ~QmitkFunctionality() override;
-  ///
-  /// Called, when the WorkbenchPart gets closed
-  /// by the user directly or by closing the whole
-  /// app (e.g. for removing event listeners)
-  ///
-  virtual void ClosePart();
-  ///
-  /// Called when the selection in the workbench changed
-  ///
-  virtual void OnSelectionChanged(std::vector<mitk::DataNode*> /*nodes*/);
-  ///
-  /// Called when the preferences object of this view changed.
-  /// \see GetPreferences()
-  ///
-  virtual void OnPreferencesChanged(const berry::IBerryPreferences*);
-  ///
-  /// Make this view manage multiple DataStorage. If set to true GetDataStorage()
-  /// will return the currently active DataStorage (and not the default one).
-  /// \see GetDataStorage()
-  ///
-  void SetHandleMultipleDataStorages(bool multiple);
-  ///
-  /// \return true if this view handles multiple DataStorages, false otherwise
-  ///
-  bool HandlesMultipleDataStorages() const;
-  ///
-  /// Called when a MultiWidget is available. Should not be used anymore, see GetActiveMultiWidget()
-  /// \see GetActiveMultiWidget()
-  ///
-  virtual void MultiWidgetAvailable(QmitkAbstractMultiWidget& multiWidget);
-  ///
-  /// Called when a MultiWidget is available. Should not be used anymore, see GetActiveMultiWidget()
-  /// \see GetActiveMultiWidget()
-  ///
-  virtual void MultiWidgetClosed(QmitkAbstractMultiWidget& multiWidget);
-  ///
-  /// Called when no MultiWidget is available anymore. Should not be used anymore, see GetActiveMultiWidget()
-  /// \see GetActiveMultiWidget()
-  ///
-  virtual void MultiWidgetNotAvailable();
-  ///
-  /// Only called when IsExclusiveFunctionality() returns true.
-  /// \see IsExclusiveFunctionality()
-  ///
-  virtual void Activated();
-  ///
-  /// \return true if this view is currently activated, false otherwise
-  ///
-  bool IsActivated() const;
-  ///
-  /// Only called when IsExclusiveFunctionality() returns true.
-  /// \see IsExclusiveFunctionality()
-  ///
-  virtual void Deactivated();
-  ///
-  /// Some functionalities need to add special interactors, removes the crosshair from the multiwidget, etc.
-  /// In this case the functionality has to tidy up when changing to another functionality
-  /// which also wants to change the "default configuration". In the old Qt3-based
-  /// version of MITK, two functionalities could never be opened at the same time so that the
-  /// methods Activated() and Deactivated() were the right place for the functionalitites to
-  /// add/remove their interactors, etc. This is still true for the new MITK Workbench,
-  /// but as there can be several functionalities visible at the same time, the behaviour concerning
-  /// when Activated() and Deactivated() are called has changed:
-  ///
-  /// 1. Activated() and Deactivated() are only called if IsExclusiveFunctionality() returns true
-  ///
-  /// 2. If only one standalone functionality is or becomes visible, Activated() will be called on that functionality
-  ///
-  /// 3. If two or more standalone functionalities are visible,
-  ///    Activated() will be called on the functionality that receives focus, Deactivated() will be called
-  ///    on the one that looses focus, gets hidden or closed
-  ///
-  ///
-  /// As a consequence of 1. if you overwrite IsExclusiveFunctionality() and let it return false, you
-  /// signalize the MITK Workbench that this functionality does nothing to the "default configuration"
-  /// and can easily be visible while other functionalities are also visible.
-  ///
-  /// By default the method returns true.
-  ///
-  /// \return true if this functionality is meant to work as a standalone view, false otherwise
-  ///
-  virtual bool IsExclusiveFunctionality() const;
-  ///
-  /// Informs other parts of the workbench that node is selected via the blueberry selection service.
-  ///
-  void FireNodeSelected(mitk::DataNode* node);
-  ///
-  /// Informs other parts of the workbench that the nodes are selected via the blueberry selection service.
-  ///
-  void FireNodesSelected(std::vector<mitk::DataNode*> nodes);
-  ///
-  /// Called when this functionality becomes visible ( no matter what IsExclusiveFunctionality() returns )
-  ///
-  virtual void Visible();
-  ///
-  /// \return true if this view is currently visible, false otherwise
-  ///
-  bool IsVisible() const;
-  ///
-  /// Called when this functionality is hidden ( no matter what IsExclusiveFunctionality() returns )
-  ///
-  virtual void Hidden();
-//# protected virtual methods which can be overwritten
-protected:
-  ///
-  /// Called when a DataStorage Add event was thrown. May be reimplemented
-  /// by deriving classes.
-  ///
-  virtual void NodeAdded(const mitk::DataNode* node);
-  ///
-  /// Called when a DataStorage Changed event was thrown. May be reimplemented
-  /// by deriving classes.
-  ///
-  virtual void NodeChanged(const mitk::DataNode* /*node*/);
-  ///
-  /// Called when a DataStorage Remove event was thrown. May be reimplemented
-  /// by deriving classes.
-  ///
-  virtual void NodeRemoved(const mitk::DataNode* node);
-  ///
-  /// Called when a DataStorage add *or* remove *or* change event was thrown. May be reimplemented
-  /// by deriving classes.
-  ///
-  virtual void DataStorageChanged();
-  ///
-  /// \return the selection of the currently active part of the workbench or an empty vector
-  ///         if nothing is selected
-  ///
-  std::vector<mitk::DataNode*> GetCurrentSelection() const;
-  ///
-  /// Returns the current selection made in the datamanager bundle or an empty vector
-  /// if nothing`s selected or if the bundle does not exist
-  ///
-  std::vector<mitk::DataNode*> GetDataManagerSelection() const;
-  ///
-  /// Returns the Preferences object for this Functionality.
-  /// <b>Important</b>: When refering to this preferences, e.g. in a PreferencePage: The ID
-  /// for this preferences object is "/<VIEW-ID>", e.g. "/org.mitk.views.datamanager"
-  ///
-  berry::IPreferences::Pointer GetPreferences() const;
-  ///
-  /// Returns the default <b>or</b> the currently active DataStorage if m_HandlesMultipleDataStorages
-  /// is set to true
-  /// \see SetHandleMultipleDataStorages(bool)
-  /// \see HandlesMultipleDataStorages()
-  ///
-  mitk::DataStorage::Pointer GetDataStorage() const;
-  ///
-  /// \return always returns the default DataStorage
-  ///
-  mitk::DataStorage::Pointer GetDefaultDataStorage() const;
-
-  mitk::IDataStorageReference::Pointer GetDataStorageReference() const;
-
-  ///
-  /// Returns the default and active MultiWidget.
-  /// \param reCreateWidget a boolean flag to en-/disable the attempt to re-create the StdWidget
-  /// <b>If there is not MultiWidget yet a new one is
-  /// created in this method when called with default parameter!</b>
-  ///
-  QmitkAbstractMultiWidget* GetActiveMultiWidget( bool reCreateWidget = true);
-  ///
-  /// Outputs an error message to the console and displays a message box containing
-  /// the exception description.
-  /// \param e the exception which should be handled
-  /// \param parent
-  /// \param showDialog controls, whether additionally a message box should be
-  ///        displayed to inform the user that something went wrong
-  ///
-  void HandleException( std::exception& e, QWidget* parent = nullptr, bool showDialog = true ) const;
-  ///
-  /// Calls HandleException ( std::exception&, QWidget*, bool ) internally
-  /// \see HandleException ( std::exception&, QWidget*, bool )
-  ///
-  void HandleException( const char* str, QWidget* parent = nullptr, bool showDialog = true ) const;
-  ///
-  /// Convenient method to set and reset a wait cursor ("hourglass")
-  ///
-  void WaitCursorOn();
-  ///
-  /// Convenient method to restore the standard cursor
-  ///
-  void WaitCursorOff();
-  ///
-  /// Convenient method to set and reset a busy cursor
-  ///
-  void BusyCursorOn();
-  ///
-  /// Convenient method to restore the standard cursor
-  ///
-  void BusyCursorOff();
-  ///
-  /// Convenient method to restore the standard cursor
-  ///
-  void RestoreOverrideCursor();
-
-//# other public methods which should not be overwritten
-public:
-  ///
-  /// Creates a scroll area for this view and calls CreateQtPartControl then
-  ///
-  void CreatePartControl(QWidget* parent) override;
-  ///
-  /// Called when this view receives the focus. Same as Activated()
-  /// \see Activated()
-  ///
-  void SetFocus() override;
-  ///
-  /// Called when a DataStorage Add Event was thrown. Sets
-  /// m_InDataStorageChanged to true and calls NodeAdded afterwards.
-  /// \see m_InDataStorageChanged
-  ///
-  void NodeAddedProxy(const mitk::DataNode* node);
-  ///
-  /// Called when a DataStorage remove event was thrown. Sets
-  /// m_InDataStorageChanged to true and calls NodeRemoved afterwards.
-  /// \see m_InDataStorageChanged
-  ///
-  void NodeRemovedProxy(const mitk::DataNode* node);
-  ///
-  /// Called when a DataStorage changed event was thrown. Sets
-  /// m_InDataStorageChanged to true and calls NodeChanged afterwards.
-  /// \see m_InDataStorageChanged
-  ///
-  void NodeChangedProxy(const mitk::DataNode* node);
-  ///
-  /// Toggles the visible flag m_Visible
-  ///
-  void SetVisible(bool visible);
-  ///
-  /// Toggles the activated flag m_Activated
-  ///
-  void SetActivated(bool activated);
-  ///
-  /// Called, when the WorkbenchPart gets closed for removing event listeners
-  /// Internally this method calls ClosePart after it removed the listeners registered
-  /// by QmitkFunctionality. By having this proxy method the user does not have to
-  /// call QmitkFunctionality::ClosePart() when overwriting ClosePart()
-  ///
-  void ClosePartProxy();
-
-//# other protected methods which should not be overwritten (or which are deprecated)
-protected:
-  ///
-  /// Called immediately after CreateQtPartControl().
-  /// Here standard event listeners for a QmitkFunctionality are registered
-  ///
-  void AfterCreateQtPartControl();
-  ///
-  /// code to activate the last visible functionality
-  ///
-  void ActivateLastVisibleFunctionality();
-  ///
-  /// reactions to selection events from data manager (and potential other senders)
-  ///
-  void BlueBerrySelectionChanged(const berry::IWorkbenchPart::Pointer& sourcepart, const berry::ISelection::ConstPointer& selection);
-  ///
-  /// Converts a mitk::DataNodeSelection to a std::vector<mitk::DataNode*> (possibly empty
-  ///
-  std::vector<mitk::DataNode*> DataNodeSelectionToVector(mitk::DataNodeSelection::ConstPointer currentSelection) const;
-  //# protected fields
-protected:
-  ///
-  /// helper stuff to observe BlueBerry selections
-  ///
-  friend struct berry::SelectionChangedAdapter<QmitkFunctionality>;
-  ///
-  /// Saves the parent of this view (this is the scrollarea created in CreatePartControl(QWidget*)
-  /// \see CreatePartControl(QWidget*)
-  ///
-  QWidget* m_Parent;
-  ///
-  /// Saves if this view is the currently active one.
-  ///
-  bool m_Active;
-  ///
-  /// Saves if this view is visible
-  ///
-  bool m_Visible;
-
-  //# private fields:
-
-private:
-  ///
-  /// Holds the current selection (selection made by this Functionality !!!)
-  ///
-  QmitkFunctionalitySelectionProvider* m_SelectionProvider;
-  ///
-  /// object to observe BlueBerry selections
-  ///
-  QScopedPointer<berry::ISelectionListener> m_BlueBerrySelectionListener;
-
-  ctkServiceTracker<mitk::IDataStorageService*> m_DataStorageServiceTracker;
-
-
-  ///
-  /// Saves if this view handles multiple datastorages
-  ///
-  bool m_HandlesMultipleDataStorages;
-  ///
-  /// Saves if this class is currently working on DataStorage changes.
-  /// This is a protector variable to avoid recursive calls on event listener functions.
-  bool m_InDataStorageChanged;
-  ///
-  /// saves all visible functionalities
-  ///
-  std::set<std::string> m_VisibleFunctionalities;
-};
-
-#endif /*QMITKFUNCTIONALITY_H_*/
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality2.cpp b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality2.cpp
deleted file mode 100644
index cc16019d2f..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality2.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include "QmitkFunctionality.h"
-#include "internal/QmitkFunctionalityUtil.h"
-
-#include <berryIWorkbenchWindow.h>
-#include <berryISelectionService.h>
-
-#include <mitkDataNodeObject.h>
-
-std::vector<mitk::DataNode*> QmitkFunctionality::GetCurrentSelection() const
-{
-  berry::ISelection::ConstPointer selection( this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection());
-  // buffer for the data manager selection
-  mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
-  return this->DataNodeSelectionToVector(currentSelection);
-}
-
-std::vector<mitk::DataNode*> QmitkFunctionality::GetDataManagerSelection() const
-{
-  berry::ISelection::ConstPointer selection( this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
-    // buffer for the data manager selection
-  mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
-  return this->DataNodeSelectionToVector(currentSelection);
-}
-
-void QmitkFunctionality::OnSelectionChanged(std::vector<mitk::DataNode*> /*nodes*/)
-{
-}
-
-std::vector<mitk::DataNode*> QmitkFunctionality::DataNodeSelectionToVector(mitk::DataNodeSelection::ConstPointer currentSelection) const
-{
-
-  std::vector<mitk::DataNode*> selectedNodes;
-  if(currentSelection.IsNull())
-    return selectedNodes;
-
-  mitk::DataNodeObject* _DataNodeObject = nullptr;
-  mitk::DataNode* _DataNode = nullptr;
-
-  for(mitk::DataNodeSelection::iterator it = currentSelection->Begin();
-    it != currentSelection->End(); ++it)
-  {
-    _DataNodeObject = dynamic_cast<mitk::DataNodeObject*>((*it).GetPointer());
-    if(_DataNodeObject)
-    {
-      _DataNode = _DataNodeObject->GetDataNode();
-      if(_DataNode)
-        selectedNodes.push_back(_DataNode);
-    }
-  }
-
-  return selectedNodes;
-}
-
-void QmitkFunctionality::NodeAddedProxy( const mitk::DataNode* node )
-{
-  // garantuee no recursions when a new node event is thrown in NodeAdded()
-  if(!m_InDataStorageChanged)
-  {
-    m_InDataStorageChanged = true;
-    this->NodeAdded(node);
-    this->DataStorageChanged();
-    m_InDataStorageChanged = false;
-  }
-
-}
-
-void QmitkFunctionality::NodeAdded( const mitk::DataNode*  /*node*/ )
-{
-
-}
-
-void QmitkFunctionality::NodeRemovedProxy( const mitk::DataNode* node )
-{
-  // garantuee no recursions when a new node event is thrown in NodeAdded()
-  if(!m_InDataStorageChanged)
-  {
-    m_InDataStorageChanged = true;
-    this->NodeRemoved(node);
-    this->DataStorageChanged();
-    m_InDataStorageChanged = false;
-  }
-}
-
-void QmitkFunctionality::NodeRemoved( const mitk::DataNode*  /*node*/ )
-{
-
-}
-
-void QmitkFunctionality::NodeChanged( const mitk::DataNode* /*node*/ )
-{
-
-}
-
-void QmitkFunctionality::NodeChangedProxy( const mitk::DataNode* node )
-{
-  // garantuee no recursions when a new node event is thrown in NodeAdded()
-  if(!m_InDataStorageChanged)
-  {
-    m_InDataStorageChanged = true;
-    this->NodeChanged(node);
-    this->DataStorageChanged();
-    m_InDataStorageChanged = false;
-  }
-}
-
-void QmitkFunctionality::FireNodeSelected( mitk::DataNode* node )
-{
-  std::vector<mitk::DataNode*> nodes;
-  nodes.push_back(node);
-  this->FireNodesSelected(nodes);
-}
-
-void QmitkFunctionality::FireNodesSelected( std::vector<mitk::DataNode*> nodes )
-{
-  if( !m_SelectionProvider )
-    return;
-
-  std::vector<mitk::DataNode::Pointer> nodesSmartPointers;
-  for (std::vector<mitk::DataNode*>::iterator it = nodes.begin()
-    ; it != nodes.end(); it++)
-  {
-    nodesSmartPointers.push_back( *it );
-  }
-  m_SelectionProvider->FireNodesSelected(nodesSmartPointers);
-
-}
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionalityCoordinator.cpp b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionalityCoordinator.cpp
deleted file mode 100644
index 8caec50f33..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionalityCoordinator.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include "QmitkFunctionalityCoordinator.h"
-#include "QmitkFunctionality.h"
-#include <QmitkStdMultiWidgetEditor.h>
-#include <berryPlatformUI.h>
-#include <berryIWorkbenchPage.h>
-
-#include <mitkIZombieViewPart.h>
-
-QmitkFunctionalityCoordinator::QmitkFunctionalityCoordinator()
-  : m_StandaloneFuntionality(nullptr)
-{
-}
-
-void QmitkFunctionalityCoordinator::Start()
-{
-  berry::PlatformUI::GetWorkbench()->AddWindowListener(this);
-  QList<berry::IWorkbenchWindow::Pointer> wnds(berry::PlatformUI::GetWorkbench()->GetWorkbenchWindows());
-  for (auto i = wnds.begin(); i != wnds.end(); ++i)
-  {
-    (*i)->GetPartService()->AddPartListener(this);
-  }
-}
-
-void QmitkFunctionalityCoordinator::Stop()
-{
-  if (!berry::PlatformUI::IsWorkbenchRunning()) return;
-
-  berry::PlatformUI::GetWorkbench()->RemoveWindowListener(this);
-  QList<berry::IWorkbenchWindow::Pointer> wnds(berry::PlatformUI::GetWorkbench()->GetWorkbenchWindows());
-  for (auto i = wnds.begin(); i != wnds.end(); ++i)
-  {
-    (*i)->GetPartService()->RemovePartListener(this);
-  }
-}
-
-QmitkFunctionalityCoordinator::~QmitkFunctionalityCoordinator()
-{
-}
-
-berry::IPartListener::Events::Types QmitkFunctionalityCoordinator::GetPartEventTypes() const
-{
-  return berry::IPartListener::Events::ACTIVATED | berry::IPartListener::Events::DEACTIVATED
-    | berry::IPartListener::Events::CLOSED | berry::IPartListener::Events::HIDDEN
-    | berry::IPartListener::Events::VISIBLE | berry::IPartListener::Events::OPENED;
-}
-
-void QmitkFunctionalityCoordinator::PartActivated( const berry::IWorkbenchPartReference::Pointer& partRef )
-{
-  // change the active standalone functionality
-  this->ActivateStandaloneFunctionality(partRef.GetPointer());
-}
-
-void QmitkFunctionalityCoordinator::PartDeactivated( const berry::IWorkbenchPartReference::Pointer& /*partRef*/ )
-{
-  // nothing to do here: see PartActivated()
-}
-
-void QmitkFunctionalityCoordinator::PartOpened( const berry::IWorkbenchPartReference::Pointer& partRef )
-{
-   // check for multiwidget and inform views that it is available now
-  if ( partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID )
-  {
-    for (std::set<QmitkFunctionality*>::iterator it = m_Functionalities.begin()
-      ; it != m_Functionalities.end(); it++)
-    {
-      (*it)->MultiWidgetAvailable(*(partRef
-        ->GetPart(false).Cast<QmitkStdMultiWidgetEditor>()->GetMultiWidget()));
-    }
-  }
-  else
-  {
-    // Check for QmitkFunctionality
-    QmitkFunctionality::Pointer _QmitkFunctionality = partRef->GetPart(false).Cast<QmitkFunctionality>();
-    if(_QmitkFunctionality.IsNotNull())
-    {
-      m_Functionalities.insert(_QmitkFunctionality.GetPointer()); // save as opened functionality
-    }
-  }
-}
-
-void QmitkFunctionalityCoordinator::PartClosed( const berry::IWorkbenchPartReference::Pointer& partRef )
-{
-  // check for multiwidget and inform views that it not available any more
-  if ( partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID )
-  {
-
-    QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast<QmitkStdMultiWidgetEditor>();
-    for (std::set<QmitkFunctionality*>::iterator it = m_Functionalities.begin()
-      ; it != m_Functionalities.end(); it++)
-    {
-      (*it)->MultiWidgetClosed(*(stdMultiWidgetEditor->GetMultiWidget()));
-      (*it)->MultiWidgetNotAvailable(); // deprecated call, provided for consistence
-    }
-  }
-  else
-  {
-    // check for functionality
-    QmitkFunctionality::Pointer _QmitkFunctionality = partRef->GetPart(false).Cast<QmitkFunctionality>();
-    if(_QmitkFunctionality.IsNotNull())
-    {
-      // deactivate on close ( the standalone functionality may still be activated  )
-      this->DeactivateStandaloneFunctionality(partRef.GetPointer(), nullptr);
-
-      // and set pointer to 0
-      if(m_StandaloneFuntionality == partRef.GetPointer())
-        m_StandaloneFuntionality = nullptr;
-
-      m_Functionalities.erase(_QmitkFunctionality.GetPointer()); // remove as opened functionality
-
-      // call PartClosed on the QmitkFunctionality
-      _QmitkFunctionality->ClosePartProxy();
-      //m_VisibleStandaloneFunctionalities.erase(_QmitkFunctionality.GetPointer()); // remove if necessary (should be done before in PartHidden()
-    }
-  }
-}
-
-void QmitkFunctionalityCoordinator::PartHidden( const berry::IWorkbenchPartReference::Pointer& partRef )
-{
-  // Check for QmitkFunctionality
-  QmitkFunctionality::Pointer _QmitkFunctionality = partRef->GetPart(false).Cast<QmitkFunctionality>();
-  if(_QmitkFunctionality != 0)
-  {
-    _QmitkFunctionality->SetVisible(false);
-    _QmitkFunctionality->Hidden();
-
-    // tracking of Visible Standalone Functionalities
-    m_VisibleStandaloneFunctionalities.erase(partRef.GetPointer());
-
-    // activate Functionality if just one Standalone Functionality is visible
-    if( m_VisibleStandaloneFunctionalities.size() == 1 )
-      this->ActivateStandaloneFunctionality( *m_VisibleStandaloneFunctionalities.begin() );
-  }
-}
-
-void QmitkFunctionalityCoordinator::PartVisible( const berry::IWorkbenchPartReference::Pointer& partRef )
-{
-  // Check for QmitkFunctionality
-  QmitkFunctionality::Pointer _QmitkFunctionality = partRef->GetPart(false).Cast<QmitkFunctionality>();
-  if(_QmitkFunctionality.IsNotNull())
-  {
-    _QmitkFunctionality->SetVisible(true);
-    _QmitkFunctionality->Visible();
-
-    // tracking of Visible Standalone Functionalities
-    if( _QmitkFunctionality->IsExclusiveFunctionality() )
-    {
-      m_VisibleStandaloneFunctionalities.insert(partRef.GetPointer());
-
-      // activate Functionality if just one Standalone Functionality is visible
-      if( m_VisibleStandaloneFunctionalities.size() == 1 )
-        this->ActivateStandaloneFunctionality( *m_VisibleStandaloneFunctionalities.begin() );
-    }
-  }
-}
-
-void QmitkFunctionalityCoordinator::ActivateStandaloneFunctionality( berry::IWorkbenchPartReference* partRef )
-{
-  QmitkFunctionality* functionality = dynamic_cast<QmitkFunctionality*>(partRef->GetPart(false).GetPointer());
-  if( functionality && !functionality->IsActivated() && functionality->IsExclusiveFunctionality() )
-  {
-    MITK_INFO << "**** Activating legacy standalone functionality";
-    // deactivate old one if necessary
-    this->DeactivateStandaloneFunctionality(m_StandaloneFuntionality, partRef);
-    m_StandaloneFuntionality = partRef;
-
-    MITK_INFO << "setting active flag";
-    // call activated on this functionality
-    functionality->SetActivated(true);
-    functionality->Activated();
-  }
-  else if (dynamic_cast<mitk::IZombieViewPart*>(partRef->GetPart(false).GetPointer()) &&
-           m_StandaloneFuntionality != partRef)
-  {
-    this->DeactivateStandaloneFunctionality(m_StandaloneFuntionality, partRef);
-    m_StandaloneFuntionality = partRef;
-  }
-}
-
-void QmitkFunctionalityCoordinator::DeactivateStandaloneFunctionality(berry::IWorkbenchPartReference* partRef,
-                                                                      berry::IWorkbenchPartReference* newRef)
-{
-  if (partRef == nullptr) return;
-
-  QmitkFunctionality* functionality = dynamic_cast<QmitkFunctionality*>(partRef->GetPart(false).GetPointer());
-  if(functionality && functionality->IsActivated())
-  {
-    functionality->SetActivated(false);
-    functionality->Deactivated();
-  }
-  else if (mitk::IZombieViewPart* zombie = dynamic_cast<mitk::IZombieViewPart*>(partRef->GetPart(false).GetPointer()))
-  {
-    zombie->ActivatedZombieView(berry::IWorkbenchPartReference::Pointer(newRef));
-  }
-}
-
-void QmitkFunctionalityCoordinator::WindowClosed(const berry::IWorkbenchWindow::Pointer& /*window*/ )
-{
-
-}
-
-void QmitkFunctionalityCoordinator::WindowOpened(const berry::IWorkbenchWindow::Pointer& window )
-{
-  window->GetPartService()->AddPartListener(this);
-}
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionalityCoordinator.h b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionalityCoordinator.h
deleted file mode 100644
index c8b1075222..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionalityCoordinator.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-
-#ifndef QmitkFunctionalityCoordinator_h
-#define QmitkFunctionalityCoordinator_h
-
-#include <berryIPartListener.h>
-#include <berryIWindowListener.h>
-#include <berryIWorkbenchWindow.h>
-
-#include <set>
-#include <org_mitk_gui_qt_common_legacy_Export.h>
-
-class QmitkFunctionality;
-
-///
-/// \ingroup org_mitk_gui_qt_common_legacy
-///
-/// A class which coordinates active QmitkFunctionalities, e.g. calling activated and hidden on them.
-///
-class MITK_QT_COMMON_LEGACY QmitkFunctionalityCoordinator : virtual public berry::IPartListener, virtual public berry::IWindowListener
-{
-public:
-
-  QmitkFunctionalityCoordinator();
-
-  ~QmitkFunctionalityCoordinator() override;
-
-  ///
-  /// Add listener
-  ///
-  void Start();
-
-  ///
-  /// Remove listener
-  ///
-  void Stop();
-
-  //#IPartListener methods (these methods internally call Activated() or other similar methods)
-  ///
-  /// \see IPartListener::GetPartEventTypes()
-  ///
-  berry::IPartListener::Events::Types GetPartEventTypes() const override;
-  ///
-  /// \see IPartListener::PartActivated()
-  ///
-  void PartActivated (const berry::IWorkbenchPartReference::Pointer& partRef) override;
-  ///
-  /// \see IPartListener::PartDeactivated()
-  ///
-  void PartDeactivated(const berry::IWorkbenchPartReference::Pointer& /*partRef*/) override;
-  ///
-  /// \see IPartListener::PartOpened()
-  ///
-  void PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef) override;
-  ///
-  /// \see IPartListener::PartClosed()
-  ///
-  void PartClosed (const berry::IWorkbenchPartReference::Pointer& partRef) override;
-  ///
-  /// \see IPartListener::PartHidden()
-  ///
-  void PartHidden (const berry::IWorkbenchPartReference::Pointer& partRef) override;
-  ///
-  /// \see IPartListener::PartVisible()
-  ///
-  void PartVisible (const berry::IWorkbenchPartReference::Pointer& partRef) override;
-
-  /**
-  * Notifies this listener that the given window has been closed.
-  */
-  void WindowClosed(const berry::IWorkbenchWindow::Pointer& window) override;
-
-  /**
-  * Notifies this listener that the given window has been opened.
-  */
-  void WindowOpened(const berry::IWorkbenchWindow::Pointer& /*window*/) override;
-
-protected:
-  ///
-  /// Activates the standalone functionality
-  ///
-  void ActivateStandaloneFunctionality(berry::IWorkbenchPartReference *partRef);
-  ///
-  /// Deactivates the standalone functionality
-  ///
-  void DeactivateStandaloneFunctionality(berry::IWorkbenchPartReference *functionality, berry::IWorkbenchPartReference *newRef);
-  ///
-  /// Saves the workbench window
-  ///
-  berry::IWorkbenchWindow::WeakPtr m_Window;
-  ///
-  /// Saves the last part that added interactors
-  ///
-  berry::IWorkbenchPartReference* m_StandaloneFuntionality;
-
-  ///
-  /// Saves all opened QmitkFclassunctionalities
-  ///
-  std::set<QmitkFunctionality*> m_Functionalities;
-  ///
-  /// Saves all visible QmitkFunctionalities
-  ///
-  std::set<berry::IWorkbenchPartReference*> m_VisibleStandaloneFunctionalities;
-};
-
-#endif // QmitkFunctionalityCoordinator_h
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkCommonLegacyActivator.cpp b/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkCommonLegacyActivator.cpp
deleted file mode 100644
index 38dd4642cd..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkCommonLegacyActivator.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#include "QmitkCommonLegacyActivator.h"
-#include <berryPlatformUI.h>
-#include <mitkLogMacros.h>
-
-ctkPluginContext* QmitkCommonLegacyActivator::m_Context = nullptr;
-
-void
-QmitkCommonLegacyActivator::start(ctkPluginContext* context)
-{
-  Q_UNUSED(context)
-
-  if(berry::PlatformUI::IsWorkbenchRunning())
-  {
-    m_FunctionalityCoordinator.Start();
-    m_Context = context;
-  }
-  else
-  {
-    MITK_ERROR << "BlueBerry Workbench not running!";
-  }
-}
-
-void
-QmitkCommonLegacyActivator::stop(ctkPluginContext* context)
-{
-  Q_UNUSED(context)
-
-  m_FunctionalityCoordinator.Stop();
-  m_Context = nullptr;
-}
-
-ctkPluginContext*QmitkCommonLegacyActivator::GetContext()
-{
-  return m_Context;
-}
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkCommonLegacyActivator.h b/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkCommonLegacyActivator.h
deleted file mode 100644
index 49407c0bc3..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkCommonLegacyActivator.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-
-#ifndef QMITKCOMMONLEGACYACTIVATOR_H_
-#define QMITKCOMMONLEGACYACTIVATOR_H_
-
-#include <ctkPluginActivator.h>
-
-#include "QmitkFunctionalityCoordinator.h"
-
-/**
- * \ingroup org_mitk_gui_qt_common_legacy_internal
- */
-class QmitkCommonLegacyActivator : public QObject, public ctkPluginActivator
-{
-  Q_OBJECT
-  Q_PLUGIN_METADATA(IID "org_mitk_gui_qt_common_legacy")
-  Q_INTERFACES(ctkPluginActivator)
-
-public:
-
-  /**
-   * Sets default StateMachine to EventMapper.
-   */
-  void start(ctkPluginContext* context) override;
-  void stop(ctkPluginContext* context) override;
-
-  static ctkPluginContext* GetContext();
-
-private:
-
-  QmitkFunctionalityCoordinator m_FunctionalityCoordinator;
-
-  static ctkPluginContext* m_Context;
-
-};
-
-#endif /* QMITKCOMMONLEGACYACTIVATOR_H_ */
-
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkFunctionalityUtil.cpp b/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkFunctionalityUtil.cpp
deleted file mode 100644
index dcff198c77..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkFunctionalityUtil.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-
-#include "QmitkFunctionalityUtil.h"
-
-#include "../QmitkFunctionality.h"
-
-QmitkFunctionalitySelectionProvider::QmitkFunctionalitySelectionProvider( QmitkFunctionality* _Functionality )
-: m_Functionality(_Functionality)
-{
-
-}
-
-QmitkFunctionalitySelectionProvider::~QmitkFunctionalitySelectionProvider()
-{
-  m_Functionality = nullptr;
-}
-
-void QmitkFunctionalitySelectionProvider::AddSelectionChangedListener( berry::ISelectionChangedListener* listener )
-{
-  m_SelectionEvents.AddListener(listener);
-}
-
-
-berry::ISelection::ConstPointer QmitkFunctionalitySelectionProvider::GetSelection() const
-{
-  return m_CurrentSelection;
-}
-
-void QmitkFunctionalitySelectionProvider::RemoveSelectionChangedListener( berry::ISelectionChangedListener* listener )
-{
-  m_SelectionEvents.RemoveListener(listener);
-}
-
-void QmitkFunctionalitySelectionProvider::SetSelection(const berry::ISelection::ConstPointer& selection )
-{
-  m_CurrentSelection = selection.Cast<const mitk::DataNodeSelection>();
-}
-
-void QmitkFunctionalitySelectionProvider::FireNodesSelected(const std::vector<mitk::DataNode::Pointer>& nodes )
-{
-  mitk::DataNodeSelection::Pointer sel(new mitk::DataNodeSelection(nodes));
-  m_CurrentSelection = sel;
-  berry::SelectionChangedEvent::Pointer event(new berry::SelectionChangedEvent(berry::ISelectionProvider::Pointer(this)
-    , m_CurrentSelection));
-  m_SelectionEvents.selectionChanged(event);
-
-}
diff --git a/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkFunctionalityUtil.h b/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkFunctionalityUtil.h
deleted file mode 100644
index 14c7521f6f..0000000000
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/internal/QmitkFunctionalityUtil.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-
-#ifndef QMITKFUNCTIONALITYUTIL_H
-#define QMITKFUNCTIONALITYUTIL_H
-
-#include <berryISelectionProvider.h>
-
-class QmitkFunctionality;
-
-#include <mitkDataNode.h>
-#include <mitkDataNodeSelection.h>
-
-///
-/// Internal class for selection providing
-///
-class QmitkFunctionalitySelectionProvider: public berry::ISelectionProvider
-{
-
-public:
-
-  ///
-  /// Creates smartpointer typedefs
-  ///
-  berryObjectMacro(QmitkFunctionalitySelectionProvider);
-
-  QmitkFunctionalitySelectionProvider(QmitkFunctionality* _Functionality);
-
-  ~QmitkFunctionalitySelectionProvider() override;
-
-  //# ISelectionProvider methods
-  ///
-  /// \see ISelectionProvider::AddSelectionChangedListener()
-  ///
-  void AddSelectionChangedListener(berry::ISelectionChangedListener* listener) override;
-  ///
-  /// \see ISelectionProvider::GetSelection()
-  ///
-  berry::ISelection::ConstPointer GetSelection() const override;
-  ///
-  /// \see ISelectionProvider::RemoveSelectionChangedListener()
-  ///
-  void RemoveSelectionChangedListener(berry::ISelectionChangedListener* listener) override;
-  ///
-  /// \see ISelectionProvider::SetSelection()
-  ///
-  void SetSelection(const berry::ISelection::ConstPointer& selection) override;
-  ///
-  /// Sends the nodes as selected to the workbench
-  ///
-  void FireNodesSelected(const std::vector<mitk::DataNode::Pointer>& nodes );
-
-protected:
-
-  ///
-  /// the functionality parent
-  ///
-  QmitkFunctionality* m_Functionality;
-  ///
-  /// Holds the current selection (selection made by m_Functionality !!!)
-  ///
-  mitk::DataNodeSelection::ConstPointer m_CurrentSelection;
-  ///
-  /// The selection events other parts can listen too
-  ///
-  berry::ISelectionChangedListener::Events m_SelectionEvents;
-};
-
-#endif // QMITKFUNCTIONALITYUTIL_H
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.cpp
index 07bd9d18be..5c557c42bd 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.cpp
@@ -1,292 +1,293 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkNodeSelectionDialog.h"
 
 #include <berryQtStyleManager.h>
 
 #include <mitkDataStorageInspectorGenerator.h>
 #include <QmitkNodeSelectionPreferenceHelper.h>
 #include <QmitkDataStorageSelectionHistoryInspector.h>
 #include <QmitkDataStorageFavoriteNodesInspector.h>
 
 QmitkNodeSelectionDialog::QmitkNodeSelectionDialog(QWidget* parent, QString title, QString hint)
   : QDialog(parent)
   , m_NodePredicate(nullptr)
   , m_SelectOnlyVisibleNodes(false)
   , m_SelectedNodes(NodeList())
   , m_SelectionMode(QAbstractItemView::SingleSelection)
 {
   m_Controls.setupUi(this);
 
   m_CheckFunction = [](const NodeList &) { return ""; };
 
   auto providers = mitk::DataStorageInspectorGenerator::GetProviders();
   auto visibleProviders = mitk::GetVisibleDataStorageInspectors();
   auto preferredID = mitk::GetPreferredDataStorageInspector();
 
   if (visibleProviders.empty())
   {
     MITK_DEBUG << "No presets for visible node selection inspectors available. Use fallback (show all available inspectors)";
     unsigned int order = 0;
     for (const auto &proIter : providers)
     {
       visibleProviders.insert(std::make_pair(order, proIter.first));
       ++order;
     }
   }
 
   int preferredIndex = 0;
   bool preferredFound = false;
   for (const auto &proIter : visibleProviders)
   {
     auto finding = providers.find(proIter.second);
     if (finding != providers.end())
     {
       if (finding->second->GetInspectorID() != QmitkDataStorageFavoriteNodesInspector::INSPECTOR_ID() && finding->second->GetInspectorID() != QmitkDataStorageSelectionHistoryInspector::INSPECTOR_ID())
       {
         auto provider = finding->second;
         this->AddPanel(provider, preferredID, preferredFound, preferredIndex);
       }
     }
     else
     {
       MITK_DEBUG << "No provider registered for inspector that is defined as visible in the preferences. Illegal inspector ID: " << proIter.second;
     }
   }
 
   if (mitk::GetShowFavoritesInspector())
   {
     auto favoritesPorvider = mitk::DataStorageInspectorGenerator::GetProvider(QmitkDataStorageFavoriteNodesInspector::INSPECTOR_ID());
     if (favoritesPorvider != nullptr)
     {
       this->AddPanel(favoritesPorvider, preferredID, preferredFound, preferredIndex);
     }
   }
 
   if (mitk::GetShowHistoryInspector())
   {
     auto historyPorvider = mitk::DataStorageInspectorGenerator::GetProvider(QmitkDataStorageSelectionHistoryInspector::INSPECTOR_ID());
     if (historyPorvider != nullptr)
     {
       this->AddPanel(historyPorvider, preferredID, preferredFound, preferredIndex);
     }
   }
 
   m_Controls.tabWidget->setCurrentIndex(preferredIndex);
   this->setWindowTitle(title);
   this->setToolTip(hint);
 
   m_Controls.hint->setText(hint);
   m_Controls.hint->setVisible(!hint.isEmpty());
   if(hint.isEmpty())
   {
     m_Controls.layoutHint->setContentsMargins(0, 0, 0, 0);
   }
   else
   {
     m_Controls.layoutHint->setContentsMargins(6, 6, 6, 6);
   }
 
   this->SetErrorText("");
 
   m_Controls.btnAddToFav->setIcon(berry::QtStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/favorite_add.svg")));
 
   connect(m_Controls.btnAddToFav, &QPushButton::clicked, this, &QmitkNodeSelectionDialog::OnFavoriteNodesButtonClicked);
   connect(m_Controls.buttonBox, &QDialogButtonBox::accepted, this, &QmitkNodeSelectionDialog::OnOK);
   connect(m_Controls.buttonBox, &QDialogButtonBox::rejected, this, &QmitkNodeSelectionDialog::OnCancel);
 }
 
 void QmitkNodeSelectionDialog::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   if (m_DataStorage != dataStorage)
   {
     m_DataStorage = dataStorage;
+    auto lockedDataStorage = m_DataStorage.Lock();
 
-    if (!m_DataStorage.IsExpired())
+    if (lockedDataStorage.IsNotNull())
     {
       for (auto panel : m_Panels)
       {
-        panel->SetDataStorage(dataStorage);
+        panel->SetDataStorage(lockedDataStorage);
       }
     }
   }
 }
 
 void QmitkNodeSelectionDialog::SetNodePredicate(const mitk::NodePredicateBase* nodePredicate)
 {
   if (m_NodePredicate != nodePredicate)
   {
     m_NodePredicate = nodePredicate;
 
     for (auto panel : m_Panels)
     {
       panel->SetNodePredicate(m_NodePredicate);
     }
   }
 }
 
 const mitk::NodePredicateBase* QmitkNodeSelectionDialog::GetNodePredicate() const
 {
   return m_NodePredicate;
 }
 
 QmitkNodeSelectionDialog::NodeList QmitkNodeSelectionDialog::GetSelectedNodes() const
 {
   return m_SelectedNodes;
 }
 
 void QmitkNodeSelectionDialog::SetSelectionCheckFunction(const SelectionCheckFunctionType &checkFunction)
 {
   m_CheckFunction = checkFunction;
   auto checkResponse = m_CheckFunction(m_SelectedNodes);
 
   SetErrorText(checkResponse);
 
   m_Controls.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(checkResponse.empty());
 }
 
 void QmitkNodeSelectionDialog::SetErrorText(const std::string& checkResponse)
 {
   m_Controls.error->setText(QString::fromStdString(checkResponse));
   m_Controls.error->setVisible(!checkResponse.empty());
   if (checkResponse.empty())
   {
     m_Controls.layoutError->setContentsMargins(0, 0, 0, 0);
   }
   else
   {
     m_Controls.layoutError->setContentsMargins(6, 6, 6, 6);
   }
 }
 
 bool QmitkNodeSelectionDialog::GetSelectOnlyVisibleNodes() const
 {
   return m_SelectOnlyVisibleNodes;
 }
 
 void QmitkNodeSelectionDialog::SetSelectionMode(SelectionMode mode)
 {
   m_SelectionMode = mode;
   for (auto panel : m_Panels)
   {
     panel->SetSelectionMode(mode);
   }
 }
 
 QmitkNodeSelectionDialog::SelectionMode QmitkNodeSelectionDialog::GetSelectionMode() const
 {
   return m_SelectionMode;
 }
 
 void QmitkNodeSelectionDialog::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
 {
   if (m_SelectOnlyVisibleNodes != selectOnlyVisibleNodes)
   {
     m_SelectOnlyVisibleNodes = selectOnlyVisibleNodes;
 
     for (auto panel : m_Panels)
     {
       panel->SetSelectOnlyVisibleNodes(m_SelectOnlyVisibleNodes);
     }
   }
 }
 
 void QmitkNodeSelectionDialog::SetCurrentSelection(NodeList selectedNodes)
 {
   m_SelectedNodes = selectedNodes;
   auto checkResponse = m_CheckFunction(m_SelectedNodes);
 
   SetErrorText(checkResponse);
 
   m_Controls.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(checkResponse.empty());
 
   for (auto panel : m_Panels)
   {
     panel->SetCurrentSelection(selectedNodes);
   }
 }
 
 void QmitkNodeSelectionDialog::OnSelectionChanged(NodeList selectedNodes)
 {
   SetCurrentSelection(selectedNodes);
   emit CurrentSelectionChanged(selectedNodes);
 }
 
 void QmitkNodeSelectionDialog::OnFavoriteNodesButtonClicked()
 {
   for (auto node : qAsConst(m_SelectedNodes))
   {
     node->SetBoolProperty("org.mitk.selection.favorite", true);
   }
 }
 
 void QmitkNodeSelectionDialog::OnOK()
 {
   for (const auto &node : qAsConst(m_SelectedNodes))
   {
     QmitkDataStorageSelectionHistoryInspector::AddNodeToHistory(node);
   }
 
   this->accept();
 }
 
 void QmitkNodeSelectionDialog::OnCancel()
 {
   this->reject();
 }
 
 void QmitkNodeSelectionDialog::AddPanel(const mitk::IDataStorageInspectorProvider * provider, const mitk::IDataStorageInspectorProvider::InspectorIDType& preferredID, bool &preferredFound, int &preferredIndex)
 {
   auto inspector = provider->CreateInspector();
   QString name = QString::fromStdString(provider->GetInspectorDisplayName());
   QString desc = QString::fromStdString(provider->GetInspectorDescription());
 
   inspector->setParent(this);
   inspector->SetSelectionMode(m_SelectionMode);
 
   auto tabPanel = new QWidget();
   tabPanel->setObjectName(QString("tab_") + name);
   tabPanel->setToolTip(desc);
 
   auto verticalLayout = new QVBoxLayout(tabPanel);
   verticalLayout->setSpacing(0);
   verticalLayout->setContentsMargins(0, 0, 0, 0);
   verticalLayout->addWidget(inspector);
 
   auto panelPos = m_Controls.tabWidget->insertTab(m_Controls.tabWidget->count(), tabPanel, name);
 
   auto icon = provider->GetInspectorIcon();
   if (!icon.isNull())
   {
     m_Controls.tabWidget->setTabIcon(panelPos, icon);
   }
 
   m_Panels.push_back(inspector);
   connect(inspector, &QmitkAbstractDataStorageInspector::CurrentSelectionChanged, this, &QmitkNodeSelectionDialog::OnSelectionChanged);
   connect(inspector->GetView(), &QAbstractItemView::doubleClicked, this, &QmitkNodeSelectionDialog::OnDoubleClicked);
 
   preferredFound = preferredFound || provider->GetInspectorID() == preferredID;
   if (!preferredFound)
   {
     ++preferredIndex;
   }
 }
 
 void QmitkNodeSelectionDialog::OnDoubleClicked(const QModelIndex& /*index*/)
 {
   const auto isOK = m_Controls.buttonBox->button(QDialogButtonBox::Ok)->isEnabled();
   if (!m_SelectedNodes.empty() && isOK)
   {
     this->OnOK();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
index b9d848b5b6..6af9236c5b 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
@@ -1,271 +1,235 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkDataManagerView.h"
 
 // mitk gui qt datamanager
 #include "internal/QmitkDataManagerItemDelegate.h"
 #include "internal/QmitkNodeTableViewKeyFilter.h"
 
 // mitk core
 #include <mitkCommon.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkEnumerationProperty.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateData.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkProperties.h>
 #include <mitkRenderingModeProperty.h>
 
 // qt widgets module
 #include <QmitkCustomVariants.h>
 #include <QmitkDataStorageFilterProxyModel.h>
 #include <QmitkDataStorageTreeModel.h>
 #include <QmitkIOUtil.h>
 #include <QmitkNodeDescriptorManager.h>
 
-// beery plugins
-#include <berryAbstractUICTKPlugin.h>
-#include <berryIContributor.h>
-#include <berryIEditorPart.h>
-#include <berryIEditorRegistry.h>
-#include <berryIExtensionRegistry.h>
-#include <berryIPreferencesService.h>
-#include <berryIWorkbenchPage.h>
-#include <berryPlatform.h>
-#include <berryPlatformUI.h>
-
 // mitk core services plugin
 #include <mitkIDataStorageReference.h>
 #include <mitkIDataStorageService.h>
 
 // mitk gui common plugin
 #include <mitkDataNodeObject.h>
-#include <mitkDataStorageEditorInput.h>
 
 // mitk gui qt application plugin
 #include <QmitkDataNodeGlobalReinitAction.h>
 #include <QmitkDataNodeToggleVisibilityAction.h>
 
 // mitk gui qt common plugin
 #include <QmitkDnDFrameWidget.h>
 
 // qt
 #include <QGridLayout>
 #include <QVBoxLayout>
-#include <QAction>
 #include <QTreeView>
-#include <QSignalMapper>
 
 const QString QmitkDataManagerView::VIEW_ID = "org.mitk.views.datamanager";
 
 QmitkDataManagerView::QmitkDataManagerView()
   : m_ItemDelegate(nullptr)
 {
 }
 
 QmitkDataManagerView::~QmitkDataManagerView()
 {
   // nothing here
 }
 
 void QmitkDataManagerView::CreateQtPartControl(QWidget* parent)
 {
   m_CurrentRowCount = 0;
   m_Parent = parent;
 
   berry::IBerryPreferences::Pointer prefs = this->GetPreferences().Cast<berry::IBerryPreferences>();
   assert(prefs);
 
   //# GUI
   m_NodeTreeModel = new QmitkDataStorageTreeModel(GetDataStorage(), prefs->GetBool("Place new nodes on top", true));
   m_NodeTreeModel->setParent(parent);
   m_NodeTreeModel->SetAllowHierarchyChange(prefs->GetBool("Allow changing of parent node", false));
   m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
   // Prepare filters
   m_HelperObjectFilterPredicate = mitk::NodePredicateOr::New(
     mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)),
     mitk::NodePredicateProperty::New("hidden object", mitk::BoolProperty::New(true)));
   m_NodeWithNoDataFilterPredicate = mitk::NodePredicateData::New(nullptr);
 
   m_FilterModel = new QmitkDataStorageFilterProxyModel();
   m_FilterModel->setSourceModel(m_NodeTreeModel);
   m_FilterModel->AddFilterPredicate(m_HelperObjectFilterPredicate);
   m_FilterModel->AddFilterPredicate(m_NodeWithNoDataFilterPredicate);
 
   m_NodeTreeView = new QTreeView;
   m_NodeTreeView->setHeaderHidden(true);
   m_NodeTreeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
   m_NodeTreeView->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_NodeTreeView->setAlternatingRowColors(true);
   m_NodeTreeView->setDragEnabled(true);
   m_NodeTreeView->setDropIndicatorShown(true);
   m_NodeTreeView->setAcceptDrops(true);
   m_NodeTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
   m_NodeTreeView->setModel(m_FilterModel);
   m_NodeTreeView->setTextElideMode(Qt::ElideMiddle);
   m_NodeTreeView->installEventFilter(new QmitkNodeTableViewKeyFilter(this, GetDataStorage()));
 
   m_ItemDelegate = new QmitkDataManagerItemDelegate(m_NodeTreeView);
   m_NodeTreeView->setItemDelegate(m_ItemDelegate);
 
   connect(m_NodeTreeModel, SIGNAL(rowsInserted(const QModelIndex&, int, int)), this, SLOT(NodeTreeViewRowsInserted(const QModelIndex&, int, int)));
   connect(m_NodeTreeModel, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), this, SLOT(NodeTreeViewRowsRemoved(const QModelIndex&, int, int)));
   connect(m_NodeTreeView->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)), this, SLOT(NodeSelectionChanged(const QItemSelection &, const QItemSelection &)));
   connect(m_NodeTreeModel, &QmitkDataStorageTreeModel::nodeVisibilityChanged, this, &QmitkDataManagerView::OnNodeVisibilityChanged);
 
   // data node context menu and menu actions
   m_DataNodeContextMenu = new QmitkDataNodeContextMenu(GetSite(), m_NodeTreeView);
   m_DataNodeContextMenu->SetDataStorage(GetDataStorage());
   m_DataNodeContextMenu->SetSurfaceDecimation(m_SurfaceDecimation);
   connect(m_NodeTreeView, SIGNAL(customContextMenuRequested(const QPoint&)), m_DataNodeContextMenu, SLOT(OnContextMenuRequested(const QPoint&)));
 
-  berry::IEditorRegistry* editorRegistry = berry::PlatformUI::GetWorkbench()->GetEditorRegistry();
-  QList<berry::IEditorDescriptor::Pointer> editors = editorRegistry->GetEditors("*.mitk");
-  if (editors.size() > 1)
-  {
-    m_ShowInMapper = new QSignalMapper(this);
-    foreach(berry::IEditorDescriptor::Pointer descriptor, editors)
-    {
-      QAction* action = new QAction(descriptor->GetLabel(), this);
-      m_ShowInActions << action;
-      m_ShowInMapper->connect(action, SIGNAL(triggered()), m_ShowInMapper, SLOT(map()));
-      m_ShowInMapper->setMapping(action, descriptor->GetId());
-    }
-    connect(m_ShowInMapper, SIGNAL(mapped(QString)), this, SLOT(ShowIn(QString)));
-  }
-
   QGridLayout* dndFrameWidgetLayout = new QGridLayout;
   dndFrameWidgetLayout->addWidget(m_NodeTreeView, 0, 0);
   dndFrameWidgetLayout->setContentsMargins(0, 0, 0, 0);
 
   m_DnDFrameWidget = new QmitkDnDFrameWidget(m_Parent);
   m_DnDFrameWidget->setLayout(dndFrameWidgetLayout);
 
   QVBoxLayout* layout = new QVBoxLayout(parent);
   layout->addWidget(m_DnDFrameWidget);
   layout->setContentsMargins(0, 0, 0, 0);
 
   m_Parent->setLayout(layout);
 }
 
 void QmitkDataManagerView::SetFocus()
 {
 }
 
 //////////////////////////////////////////////////////////////////////////
 // Node tree modification
 //////////////////////////////////////////////////////////////////////////
 void QmitkDataManagerView::NodeTreeViewRowsInserted(const QModelIndex& parent, int /*start*/, int /*end*/)
 {
   QModelIndex viewIndex = m_FilterModel->mapFromSource(parent);
   m_NodeTreeView->setExpanded(viewIndex, true);
 
   // a new row was inserted
   if (m_CurrentRowCount == 0 && m_NodeTreeModel->rowCount() == 1)
   {
     mitk::WorkbenchUtil::OpenRenderWindowPart(GetSite()->GetPage());
     m_CurrentRowCount = m_NodeTreeModel->rowCount();
   }
 }
 
 void QmitkDataManagerView::NodeTreeViewRowsRemoved(const QModelIndex& /*parent*/, int /*start*/, int /*end*/)
 {
   m_CurrentRowCount = m_NodeTreeModel->rowCount();
 }
 
 void QmitkDataManagerView::NodeSelectionChanged(const QItemSelection& /*selected*/, const QItemSelection& /*deselected*/)
 {
   auto selectedNodes = GetCurrentSelection();
   auto nodeSet = m_NodeTreeModel->GetNodeSet();
 
   for (auto node : qAsConst(nodeSet))
   {
     if (node.IsNotNull())
     {
       node->SetSelected(selectedNodes.contains(node));
     }
   }
   m_DataNodeContextMenu->SetSelectedNodes(selectedNodes);
 }
 
 void QmitkDataManagerView::OnNodeVisibilityChanged()
 {
   ToggleVisibilityAction::Run(GetSite(), GetDataStorage(), QList<mitk::DataNode::Pointer>());
 }
 
-void QmitkDataManagerView::ShowIn(const QString& editorId)
-{
-  berry::IWorkbenchPage::Pointer page = GetSite()->GetPage();
-  berry::IEditorInput::Pointer input(new mitk::DataStorageEditorInput(GetDataStorageReference()));
-  page->OpenEditor(input, editorId, false, berry::IWorkbenchPage::MATCH_ID);
-}
-
 void QmitkDataManagerView::NodeChanged(const mitk::DataNode* /*node*/)
 {
   // m_FilterModel->invalidate();
   // fix as proposed by R. Khlebnikov in the mitk-users mail from 02.09.2014
   QMetaObject::invokeMethod(m_FilterModel, "invalidate", Qt::QueuedConnection);
 }
 
 void QmitkDataManagerView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   if (m_NodeTreeModel->GetPlaceNewNodesOnTopFlag() != prefs->GetBool("Place new nodes on top", true))
   {
     m_NodeTreeModel->SetPlaceNewNodesOnTop(!m_NodeTreeModel->GetPlaceNewNodesOnTopFlag());
   }
 
   bool hideHelperObjects = !prefs->GetBool("Show helper objects", false);
   if (m_FilterModel->HasFilterPredicate(m_HelperObjectFilterPredicate) != hideHelperObjects)
   {
     if (hideHelperObjects)
     {
       m_FilterModel->AddFilterPredicate(m_HelperObjectFilterPredicate);
     }
     else
     {
       m_FilterModel->RemoveFilterPredicate(m_HelperObjectFilterPredicate);
     }
   }
 
   bool hideNodesWithNoData = !prefs->GetBool("Show nodes containing no data", false);
   if (m_FilterModel->HasFilterPredicate(m_NodeWithNoDataFilterPredicate) != hideNodesWithNoData)
   {
     if (hideNodesWithNoData)
     {
       m_FilterModel->AddFilterPredicate(m_NodeWithNoDataFilterPredicate);
     }
     else
     {
       m_FilterModel->RemoveFilterPredicate(m_NodeWithNoDataFilterPredicate);
     }
   }
   m_NodeTreeView->expandAll();
 
   m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
   m_DataNodeContextMenu->SetSurfaceDecimation(m_SurfaceDecimation);
 
   m_NodeTreeModel->SetAllowHierarchyChange(prefs->GetBool("Allow changing of parent node", false));
 
   GlobalReinitAction::Run(GetSite(), GetDataStorage());
 }
 
 QItemSelectionModel* QmitkDataManagerView::GetDataNodeSelectionModel() const
 {
   return m_NodeTreeView->selectionModel();
 }
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.h b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.h
index cf6e3fd0d1..d788e63c56 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.h
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.h
@@ -1,138 +1,127 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKDATAMANAGERVIEW_H
 #define QMITKDATAMANAGERVIEW_H
 
 #include <org_mitk_gui_qt_datamanager_Export.h>
 
 // mitk core
 #include <mitkNodePredicateBase.h>
 
 // berry plugin
 #include <berryIBerryPreferences.h>
 
 // mitk gui qt common plugin
 #include <QmitkAbstractView.h>
 
 // mitk gui qt application
 #include <QmitkDataNodeContextMenu.h>
 
 // qt
 #include <QItemSelection>
 
 // forward declarations
-class QAction;
 class QModelIndex;
 class QTreeView;
-class QSignalMapper;
 
 class QmitkDnDFrameWidget;
 class QmitkDataStorageTreeModel;
 class QmitkDataManagerItemDelegate;
 class QmitkDataStorageFilterProxyModel;
 
 /**
 * @brief A view that shows all data nodes of the data storage in a qt tree view.
 *
 */
 class MITK_QT_DATAMANAGER QmitkDataManagerView : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   static const QString VIEW_ID; // = "org.mitk.views.datamanager"
 
   QmitkDataManagerView();
 
   ~QmitkDataManagerView() override;
 
 public Q_SLOTS:
 
   // invoked when the berry preferences were changed
   void OnPreferencesChanged(const berry::IBerryPreferences* prefs) override;
 
   //////////////////////////////////////////////////////////////////////////
   // Slots for Qt node tree signals
   //////////////////////////////////////////////////////////////////////////
   /// When rows are inserted auto expand them
   void NodeTreeViewRowsInserted(const QModelIndex& parent, int start, int end);
 
   /// will setup m_CurrentRowCount
   void NodeTreeViewRowsRemoved(const QModelIndex& parent, int start, int end);
 
   /// Whenever the selection changes set the "selected" property respectively
   void NodeSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected);
 
   void OnNodeVisibilityChanged();
 
-  /// Opens the editor with the given id using the current data storage
-  void ShowIn(const QString& editorId);
-
 protected:
 
   void CreateQtPartControl(QWidget* parent) override;
 
   void SetFocus() override;
   ///
   /// React to node changes. Overridden from QmitkAbstractView.
   ///
   void NodeChanged(const mitk::DataNode* node) override;
 
 protected:
 
   QWidget* m_Parent;
   QmitkDnDFrameWidget* m_DnDFrameWidget;
 
   ///
   /// \brief A plain widget as the base pane.
   ///
   QmitkDataStorageTreeModel* m_NodeTreeModel;
   QmitkDataStorageFilterProxyModel* m_FilterModel;
   mitk::NodePredicateBase::Pointer m_HelperObjectFilterPredicate;
   mitk::NodePredicateBase::Pointer m_NodeWithNoDataFilterPredicate;
   ///
   /// Holds the preferences for the data manager.
   ///
   berry::IBerryPreferences::Pointer m_DataManagerPreferencesNode;
   ///
   /// \brief The Table view to show the selected nodes.
   ///
   QTreeView* m_NodeTreeView;
   ///
   /// \brief The context menu that shows up when right clicking on a node.
   ///
   QmitkDataNodeContextMenu* m_DataNodeContextMenu;
   ///
   /// \brief flag indicating whether a surface created from a selected decimation is decimated with vtkQuadricDecimation or not
   ///
   bool m_SurfaceDecimation;
 
-  /// Maps "Show in" actions to editor ids
-  QSignalMapper* m_ShowInMapper;
-
-  /// A list of "Show in" actions
-  QList<QAction*> m_ShowInActions;
-
   /// saves the current amount of rows shown in the data manager
   size_t m_CurrentRowCount;
 
   QmitkDataManagerItemDelegate* m_ItemDelegate;
 
 private:
 
   QItemSelectionModel* GetDataNodeSelectionModel() const override;
 
 };
 
 #endif // QMITKDATAMANAGERVIEW_H
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkNodeTableViewKeyFilter.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkNodeTableViewKeyFilter.cpp
index 3360f2b276..59568929bb 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkNodeTableViewKeyFilter.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/internal/QmitkNodeTableViewKeyFilter.cpp
@@ -1,116 +1,116 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkNodeTableViewKeyFilter.h"
 #include "../QmitkDataManagerView.h"
 
 // mitk gui qt application plugin
 #include <QmitkDataNodeGlobalReinitAction.h>
 #include <QmitkDataNodeHideAllAction.h>
 #include <QmitkDataNodeReinitAction.h>
 #include <QmitkDataNodeRemoveAction.h>
 #include <QmitkDataNodeShowDetailsAction.h>
 #include <QmitkDataNodeToggleVisibilityAction.h>
 
 #include "berryIPreferencesService.h"
 #include "berryPlatform.h"
 
 // qt
 #include <QKeyEvent>
 #include <QKeySequence>
 
 QmitkNodeTableViewKeyFilter::QmitkNodeTableViewKeyFilter(QObject *dataManagerView, mitk::DataStorage *dataStorage)
   : QObject(dataManagerView), m_DataStorage(dataStorage)
 {
   m_PreferencesService = berry::Platform::GetPreferencesService();
 }
 
 bool QmitkNodeTableViewKeyFilter::eventFilter(QObject *obj, QEvent *event)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     // standard event processing
     return QObject::eventFilter(obj, event);
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   QmitkDataManagerView *dataManagerView = qobject_cast<QmitkDataManagerView *>(this->parent());
   if (event->type() == QEvent::KeyPress && dataManagerView)
   {
     berry::IPreferences::Pointer nodeTableKeyPrefs =
       m_PreferencesService->GetSystemPreferences()->Node("/DataManager/Hotkeys");
 
     QKeySequence makeAllInvisible = QKeySequence(nodeTableKeyPrefs->Get("Make all nodes invisible", "Ctrl+V"));
     QKeySequence toggleVisibility = QKeySequence(nodeTableKeyPrefs->Get("Toggle visibility of selected nodes", "V"));
     QKeySequence deleteSelectedNodes = QKeySequence(nodeTableKeyPrefs->Get("Delete selected nodes", "Del"));
     QKeySequence reinit = QKeySequence(nodeTableKeyPrefs->Get("Reinit selected nodes", "R"));
     QKeySequence globalReinit = QKeySequence(nodeTableKeyPrefs->Get("Global reinit", "Ctrl+R"));
     QKeySequence showInfo = QKeySequence(nodeTableKeyPrefs->Get("Show node information", "Ctrl+I"));
 
     QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
     QKeySequence keySequence = QKeySequence(keyEvent->modifiers() + keyEvent->key());
     // if no modifier was pressed the sequence is now empty
     if (keySequence.isEmpty())
     {
       keySequence = QKeySequence(keyEvent->key());
     }
 
     auto selectedNodes = AbstractDataNodeAction::GetSelectedNodes(dataManagerView->GetSite());
     if (keySequence == makeAllInvisible)
     {
       if (selectedNodes.empty())
       {
         // if no nodes are selected, hide all nodes of the data storage
         auto nodeset = dataStorage->GetAll();
         for (auto it = nodeset->Begin(); it != nodeset->End(); ++it)
         {
           mitk::DataNode* node = it->Value();
           if (nullptr != node)
           {
             selectedNodes.push_back(node);
           }
         }
       }
 
       HideAllAction::Run(selectedNodes);
       return true;
     }
     if (keySequence == deleteSelectedNodes)
     {
       RemoveAction::Run(dataManagerView->GetSite(), dataStorage, selectedNodes);
       return true;
     }
     if (keySequence == toggleVisibility)
     {
       ToggleVisibilityAction::Run(dataManagerView->GetSite(), dataStorage, selectedNodes);
       return true;
     }
     if (keySequence == reinit)
     {
       ReinitAction::Run(dataManagerView->GetSite(), dataStorage, selectedNodes);
       return true;
     }
     if (keySequence == globalReinit)
     {
       GlobalReinitAction::Run(dataManagerView->GetSite(), dataStorage);
       return true;
     }
     if (keySequence == showInfo)
     {
       ShowDetailsAction::Run(selectedNodes);
       return true;
     }
   }
   // standard event processing
   return QObject::eventFilter(obj, event);
 }
diff --git a/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTDoseVisualizer.h b/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTDoseVisualizer.h
index 4570098249..2181adbeb5 100644
--- a/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTDoseVisualizer.h
+++ b/Plugins/org.mitk.gui.qt.dosevisualization/src/internal/RTDoseVisualizer.h
@@ -1,172 +1,169 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef RTDoseVisualizer_h
 #define RTDoseVisualizer_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_RTDoseVisualizerControls.h"
 
 #include <mitkIsoDoseLevelCollections.h>
 
 #include <mitkImage.h>
 
 #include <mitkNodePredicateBase.h>
 
 #include "mitkDoseVisPreferenceHelper.h"
 
 // Shader
 #include <mitkCoreServices.h>
 
 #include <vtkSmartPointer.h>
 #include <mitkRenderingModeProperty.h>
 
 #include <vtkContourFilter.h>
 
 #include <mitkIRenderWindowPart.h>
 
 /*forward declarations*/
 class QmitkIsoDoseLevelSetModel;
 class QmitkDoseColorDelegate;
 class QmitkDoseValueDelegate;
 class QmitkDoseVisualStyleDelegate;
 class ctkEvent;
 
 /**
 \brief RTDoseVisualizer
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
 \sa QmitkAbstractView
 \ingroup ${plugin_target}_internal
 */
 class RTDoseVisualizer : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   RTDoseVisualizer();
   ~RTDoseVisualizer() override;
   static const std::string VIEW_ID;
   static const std::string ISO_LINE_NODE_NAME;
 
   void OnSliceChanged(itk::Object *sender, const itk::EventObject &e);
 
   protected slots:
 
     void OnAddFreeValueClicked();
 
     void OnRemoveFreeValueClicked();
 
     void OnUsePrescribedDoseClicked();
 
     void OnDataChangedInIsoLevelSetView();
 
     void OnAbsDoseToggled(bool);
 
     void OnGlobalVisColorWashToggled(bool);
 
     void OnGlobalVisIsoLineToggled(bool);
 
     void OnShowContextMenuIsoSet(const QPoint&);
 
     void OnCurrentPresetChanged(const QString&);
 
     void OnReferenceDoseChanged(double);
 
     void OnHandleCTKEventReferenceDoseChanged(const ctkEvent& event);
 
     void OnHandleCTKEventPresetsChanged(const ctkEvent& event);
 
     void OnHandleCTKEventGlobalVisChanged(const ctkEvent& event);
 
     void ActualizeFreeIsoLine();
 
 protected:
 
   void CreateQtPartControl(QWidget *parent) override;
 
   void SetFocus() override;
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
   void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
     const QList<mitk::DataNode::Pointer>& nodes ) override;
 
   void PrepareDoseNode(mitk::DataNode* doseNode) const;
 
   /** Update the transfer funtion property for the color wash*/
   void UpdateColorWashTransferFunction();
 
   /** Method updates the list widget according to the current free iso values.*/
   void UpdateFreeIsoValues();
 
   /** Update the members according to the currently selected node */
   void UpdateBySelectedNode();
 
   /** Update the member widgets according to the information stored in the application preferences*/
   void UpdateByPreferences();
 
   /**helper function that iterates throug all data nodes and sets there iso level set property
   according to the selected preset.
   @TODO: should be moved outside the class, to be available for other classes at well.*/
   void ActualizeIsoLevelsForAllDoseDataNodes();
 
   /**helper function that iterates throug all data nodes and sets there reference dose value
   according to the preference.
   @TODO: should be moved outside the class, to be available for other classes at well.*/
   void ActualizeReferenceDoseForAllDoseDataNodes();
 
   /**helper function that iterates through all data nodes and sets there dose display style (relative/absolute)
   according to the preference.
   @TODO: should be moved outside the class, to be available for other classes at well.*/
   void ActualizeDisplayStyleForAllDoseDataNodes();
 
   void NodeRemoved(const mitk::DataNode* node) override;
 
   void NodeChanged(const mitk::DataNode *node) override;
 
   Ui::RTDoseVisualizerControls m_Controls;
   mitk::DataNode::Pointer m_selectedNode;
   unsigned int m_freeIsoValuesCount;
 
   mitk::PresetMapType m_Presets;
   std::string m_selectedPresetName;
 
   /** Prescribed Dose of the selected data.*/
   mitk::DoseValueAbs m_PrescribedDose_Data;
 
   QmitkIsoDoseLevelSetModel* m_LevelSetModel;
   QmitkDoseColorDelegate* m_DoseColorDelegate;
   QmitkDoseValueDelegate* m_DoseValueDelegate;
   QmitkDoseVisualStyleDelegate* m_DoseVisualDelegate;
 
   bool m_internalUpdate;
 
   /**Predicate for dose nodes (excluding iso line nodes)*/
   mitk::NodePredicateBase::Pointer m_isDosePredicate;
   /**Predicate for dose nodes and all iso line nodes*/
   mitk::NodePredicateBase::Pointer m_isDoseOrIsoPredicate;
   /**Predicate for iso line nodes*/
   mitk::NodePredicateBase::Pointer m_isIsoPredicate;
 
 private:
   mitk::DataNode::Pointer GetIsoDoseNode(mitk::DataNode::Pointer doseNode) const;
 };
 
 #endif // RTDoseVisualizer_h
diff --git a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
index ea07102a60..1ff5df4acd 100644
--- a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
+++ b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
@@ -1,1431 +1,1437 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkExtWorkbenchWindowAdvisor.h"
 #include "QmitkExtActionBarAdvisor.h"
 
 #include <QMenu>
 #include <QMenuBar>
 #include <QMainWindow>
 #include <QStatusBar>
 #include <QString>
 #include <QFile>
 #include <QRegExp>
 #include <QTextStream>
 #include <QSettings>
 
 #include <ctkPluginException.h>
 #include <service/event/ctkEventAdmin.h>
 
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIActionBarConfigurer.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryIPerspectiveDescriptor.h>
 #include <berryIProduct.h>
 #include <berryIWorkbenchPartConstants.h>
 #include <berryQtPreferences.h>
 #include <berryQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 
 #include <internal/berryQtShowViewAction.h>
 #include <internal/berryQtOpenPerspectiveAction.h>
 
 #include <QmitkFileOpenAction.h>
 #include <QmitkFileSaveAction.h>
 #include <QmitkExtFileSaveProjectAction.h>
 #include <QmitkFileExitAction.h>
 #include <QmitkCloseProjectAction.h>
 #include <QmitkUndoAction.h>
 #include <QmitkRedoAction.h>
 #include <QmitkDefaultDropTargetListener.h>
 #include <QmitkStatusBar.h>
 #include <QmitkProgressBar.h>
 #include <QmitkMemoryUsageIndicatorView.h>
 #include <QmitkPreferencesDialog.h>
 #include <QmitkOpenDicomEditorAction.h>
 #include <QmitkOpenMxNMultiWidgetEditorAction.h>
 #include <QmitkOpenStdMultiWidgetEditorAction.h>
 
 #include <itkConfigure.h>
 #include <mitkVersion.h>
 #include <mitkIDataStorageService.h>
 #include <mitkIDataStorageReference.h>
 #include <mitkDataStorageEditorInput.h>
 #include <mitkWorkbenchUtil.h>
 #include <vtkVersionMacros.h>
 
 // UGLYYY
 #include "internal/QmitkExtWorkbenchWindowAdvisorHack.h"
 #include "internal/QmitkCommonExtPlugin.h"
 #include "mitkUndoController.h"
 #include "mitkVerboseLimitedLinearUndo.h"
 #include <QToolBar>
 #include <QToolButton>
 #include <QMessageBox>
 #include <QMouseEvent>
 #include <QLabel>
 #include <QmitkAboutDialog.h>
 
 QmitkExtWorkbenchWindowAdvisorHack* QmitkExtWorkbenchWindowAdvisorHack::undohack =
   new QmitkExtWorkbenchWindowAdvisorHack();
 
 QString QmitkExtWorkbenchWindowAdvisor::QT_SETTINGS_FILENAME = "QtSettings.ini";
 
 static bool USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS = false;
 
 class PartListenerForTitle: public berry::IPartListener
 {
 public:
 
   PartListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
   {
   }
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::ACTIVATED | Events::BROUGHT_TO_TOP | Events::CLOSED
       | Events::HIDDEN | Events::VISIBLE;
   }
 
   void PartActivated(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref.Cast<berry::IEditorReference> ())
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
   void PartBroughtToTop(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref.Cast<berry::IEditorReference> ())
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& /*ref*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
-    if (!windowAdvisor->lastActiveEditor.Expired() &&
-      ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
+    auto lockedLastActiveEditor = windowAdvisor->lastActiveEditor.Lock();
+
+    if (lockedLastActiveEditor.IsNotNull() && ref->GetPart(false) == lockedLastActiveEditor)
     {
       windowAdvisor->UpdateTitle(true);
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
-    if (!windowAdvisor->lastActiveEditor.Expired() &&
-      ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
+    auto lockedLastActiveEditor = windowAdvisor->lastActiveEditor.Lock();
+
+    if (lockedLastActiveEditor.IsNotNull() && ref->GetPart(false) == lockedLastActiveEditor)
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
 private:
   QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
 };
 
 class PartListenerForViewNavigator: public berry::IPartListener
 {
 public:
 
   PartListenerForViewNavigator(QAction* act)
     : viewNavigatorAction(act)
   {
   }
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::OPENED | Events::CLOSED | Events::HIDDEN |
       Events::VISIBLE;
   }
 
   void PartOpened(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.viewnavigator")
     {
       viewNavigatorAction->setChecked(true);
     }
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.viewnavigator")
     {
       viewNavigatorAction->setChecked(false);
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.viewnavigator")
     {
       viewNavigatorAction->setChecked(true);
     }
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.viewnavigator")
     {
       viewNavigatorAction->setChecked(false);
     }
   }
 
 private:
   QAction* viewNavigatorAction;
 };
 
 class PartListenerForImageNavigator: public berry::IPartListener
 {
 public:
 
   PartListenerForImageNavigator(QAction* act)
     : imageNavigatorAction(act)
   {
   }
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::OPENED | Events::CLOSED | Events::HIDDEN |
       Events::VISIBLE;
   }
 
   void PartOpened(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(true);
     }
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(false);
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(true);
     }
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(false);
     }
   }
 
 private:
   QAction* imageNavigatorAction;
 };
 
 class PerspectiveListenerForTitle: public berry::IPerspectiveListener
 {
 public:
 
   PerspectiveListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
     , perspectivesClosed(false)
   {
   }
 
   Events::Types GetPerspectiveEventTypes() const override
   {
     if (USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS)
     {
       return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED;
     }
     else
     {
       return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED
         | Events::CLOSED | Events::OPENED;
     }
   }
 
   void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveSavedAs(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*oldPerspective*/,
     const berry::IPerspectiveDescriptor::Pointer& /*newPerspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveOpened(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     if (perspectivesClosed)
     {
       QListIterator<QAction*> i(windowAdvisor->viewActions);
       while (i.hasNext())
       {
         i.next()->setEnabled(true);
       }
 
       //GetViewRegistry()->Find("org.mitk.views.imagenavigator");
       if(windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
       {
         windowAdvisor->openDicomEditorAction->setEnabled(true);
       }
       if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
       {
         windowAdvisor->openStdMultiWidgetEditorAction->setEnabled(true);
       }
       if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
       {
         windowAdvisor->openMxNMultiWidgetEditorAction->setEnabled(true);
       }
 
       windowAdvisor->fileSaveProjectAction->setEnabled(true);
       windowAdvisor->closeProjectAction->setEnabled(true);
       windowAdvisor->undoAction->setEnabled(true);
       windowAdvisor->redoAction->setEnabled(true);
       windowAdvisor->imageNavigatorAction->setEnabled(true);
       windowAdvisor->viewNavigatorAction->setEnabled(true);
       windowAdvisor->resetPerspAction->setEnabled(true);
       if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
       {
         windowAdvisor->closePerspAction->setEnabled(true);
       }
     }
 
     perspectivesClosed = false;
   }
 
   void PerspectiveClosed(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     berry::IWorkbenchWindow::Pointer wnd = windowAdvisor->GetWindowConfigurer()->GetWindow();
     bool allClosed = true;
     if (wnd->GetActivePage())
     {
       QList<berry::IPerspectiveDescriptor::Pointer> perspectives(wnd->GetActivePage()->GetOpenPerspectives());
       allClosed = perspectives.empty();
     }
 
     if (allClosed)
     {
       perspectivesClosed = true;
 
       QListIterator<QAction*> i(windowAdvisor->viewActions);
       while (i.hasNext())
       {
         i.next()->setEnabled(false);
       }
 
       if(windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
       {
         windowAdvisor->openDicomEditorAction->setEnabled(false);
       }
       if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
       {
         windowAdvisor->openStdMultiWidgetEditorAction->setEnabled(false);
       }
       if (windowAdvisor->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
       {
         windowAdvisor->openMxNMultiWidgetEditorAction->setEnabled(false);
       }
 
       windowAdvisor->fileSaveProjectAction->setEnabled(false);
       windowAdvisor->closeProjectAction->setEnabled(false);
       windowAdvisor->undoAction->setEnabled(false);
       windowAdvisor->redoAction->setEnabled(false);
       windowAdvisor->imageNavigatorAction->setEnabled(false);
       windowAdvisor->viewNavigatorAction->setEnabled(false);
       windowAdvisor->resetPerspAction->setEnabled(false);
       if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
       {
         windowAdvisor->closePerspAction->setEnabled(false);
       }
     }
   }
 
 private:
   QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
   bool perspectivesClosed;
 };
 
 class PerspectiveListenerForMenu: public berry::IPerspectiveListener
 {
 public:
 
   PerspectiveListenerForMenu(QmitkExtWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
   {
   }
 
   Events::Types GetPerspectiveEventTypes() const override
   {
     return Events::ACTIVATED | Events::DEACTIVATED;
   }
 
   void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& perspective) override
   {
     QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
     if (action)
     {
       action->setChecked(true);
     }
   }
 
   void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& perspective) override
   {
     QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
     if (action)
     {
       action->setChecked(false);
     }
   }
 
 private:
   QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
 };
 
 QmitkExtWorkbenchWindowAdvisor::QmitkExtWorkbenchWindowAdvisor(berry::WorkbenchAdvisor* wbAdvisor,
                                                                berry::IWorkbenchWindowConfigurer::Pointer configurer)
   : berry::WorkbenchWindowAdvisor(configurer)
   , lastInput(nullptr)
   , wbAdvisor(wbAdvisor)
   , showViewToolbar(true)
   , showPerspectiveToolbar(false)
   , showVersionInfo(true)
   , showMitkVersionInfo(true)
   , showViewMenuItem(true)
   , showNewWindowMenuItem(false)
   , showClosePerspectiveMenuItem(true)
   , viewNavigatorFound(false)
   , showMemoryIndicator(true)
   , dropTargetListener(new QmitkDefaultDropTargetListener)
 {
   productName = QCoreApplication::applicationName();
   viewExcludeList.push_back("org.mitk.views.viewnavigator");
 }
 
 QmitkExtWorkbenchWindowAdvisor::~QmitkExtWorkbenchWindowAdvisor()
 {
 }
 
 berry::ActionBarAdvisor::Pointer QmitkExtWorkbenchWindowAdvisor::CreateActionBarAdvisor(berry::IActionBarConfigurer::Pointer configurer)
 {
   if (USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS)
   {
     berry::ActionBarAdvisor::Pointer actionBarAdvisor(new QmitkExtActionBarAdvisor(configurer));
     return actionBarAdvisor;
   }
   else
   {
     return berry::WorkbenchWindowAdvisor::CreateActionBarAdvisor(configurer);
   }
 }
 
 QWidget* QmitkExtWorkbenchWindowAdvisor::CreateEmptyWindowContents(QWidget* parent)
 {
   QWidget* parentWidget = static_cast<QWidget*>(parent);
   auto   label = new QLabel(parentWidget);
   label->setText("<b>No perspectives are open. Open a perspective in the <i>Window->Open Perspective</i> menu.</b>");
   label->setContentsMargins(10,10,10,10);
   label->setAlignment(Qt::AlignTop);
   label->setEnabled(false);
   parentWidget->layout()->addWidget(label);
   return label;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowClosePerspectiveMenuItem(bool show)
 {
   showClosePerspectiveMenuItem = show;
 }
 
 bool QmitkExtWorkbenchWindowAdvisor::GetShowClosePerspectiveMenuItem()
 {
   return showClosePerspectiveMenuItem;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowMemoryIndicator(bool show)
 {
   showMemoryIndicator = show;
 }
 
 bool QmitkExtWorkbenchWindowAdvisor::GetShowMemoryIndicator()
 {
   return showMemoryIndicator;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowNewWindowMenuItem(bool show)
 {
   showNewWindowMenuItem = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowViewToolbar(bool show)
 {
   showViewToolbar = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowViewMenuItem(bool show)
 {
   showViewMenuItem = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowPerspectiveToolbar(bool show)
 {
   showPerspectiveToolbar = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowVersionInfo(bool show)
 {
   showVersionInfo = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::ShowMitkVersionInfo(bool show)
 {
   showMitkVersionInfo = show;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetProductName(const QString& product)
 {
   productName = product;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetWindowIcon(const QString& wndIcon)
 {
   windowIcon = wndIcon;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
 {
   // very bad hack...
   berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
   QMainWindow* mainWindow = qobject_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   if (!windowIcon.isEmpty())
   {
     mainWindow->setWindowIcon(QIcon(windowIcon));
   }
   mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
 
   // Load icon theme
   QIcon::setThemeSearchPaths(QStringList() << QStringLiteral(":/org_mitk_icons/icons/"));
   QIcon::setThemeName(QStringLiteral("awesome"));
 
   // ==== Application menu ============================
 
   QMenuBar* menuBar = mainWindow->menuBar();
   menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
 
 #ifdef __APPLE__
   menuBar->setNativeMenuBar(true);
 #else
   menuBar->setNativeMenuBar(false);
 #endif
 
   auto basePath = QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/");
 
   auto fileOpenAction = new QmitkFileOpenAction(berry::QtStyleManager::ThemeIcon(basePath + "document-open.svg"), window);
   fileOpenAction->setShortcut(QKeySequence::Open);
   auto fileSaveAction = new QmitkFileSaveAction(berry::QtStyleManager::ThemeIcon(basePath + "document-save.svg"), window);
   fileSaveAction->setShortcut(QKeySequence::Save);
   fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
   fileSaveProjectAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "document-save.svg"));
   closeProjectAction = new QmitkCloseProjectAction(window);
   closeProjectAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "edit-delete.svg"));
 
   auto   perspGroup = new QActionGroup(menuBar);
   std::map<QString, berry::IViewDescriptor::Pointer> VDMap;
 
   // sort elements (converting vector to map...)
   QList<berry::IViewDescriptor::Pointer>::const_iterator iter;
 
   berry::IViewRegistry* viewRegistry =
     berry::PlatformUI::GetWorkbench()->GetViewRegistry();
   const QList<berry::IViewDescriptor::Pointer> viewDescriptors = viewRegistry->GetViews();
 
   bool skip = false;
   for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
   {
     // if viewExcludeList is set, it contains the id-strings of view, which
     // should not appear as an menu-entry in the menu
     if (viewExcludeList.size() > 0)
     {
       for (int i=0; i<viewExcludeList.size(); i++)
       {
         if (viewExcludeList.at(i) == (*iter)->GetId())
         {
           skip = true;
           break;
         }
       }
       if (skip)
       {
         skip = false;
         continue;
       }
     }
 
     if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
       continue;
     if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
       continue;
     if ((*iter)->GetId() == "org.mitk.views.viewnavigator")
       continue;
 
     std::pair<QString, berry::IViewDescriptor::Pointer> p((*iter)->GetLabel(), (*iter));
     VDMap.insert(p);
   }
 
   std::map<QString, berry::IViewDescriptor::Pointer>::const_iterator MapIter;
   for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
   {
     berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window, (*MapIter).second);
     viewActions.push_back(viewAction);
   }
 
   if (!USE_EXPERIMENTAL_COMMAND_CONTRIBUTIONS)
   {
     QMenu* fileMenu = menuBar->addMenu("&File");
     fileMenu->setObjectName("FileMenu");
     fileMenu->addAction(fileOpenAction);
     fileMenu->addAction(fileSaveAction);
     fileMenu->addAction(fileSaveProjectAction);
     fileMenu->addAction(closeProjectAction);
     fileMenu->addSeparator();
 
     QAction* fileExitAction = new QmitkFileExitAction(window);
     fileExitAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "system-log-out.svg"));
     fileExitAction->setShortcut(QKeySequence::Quit);
     fileExitAction->setObjectName("QmitkFileExitAction");
     fileMenu->addAction(fileExitAction);
 
     // another bad hack to get an edit/undo menu...
     QMenu* editMenu = menuBar->addMenu("&Edit");
     undoAction = editMenu->addAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-undo.svg"),
       "&Undo",
       QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
       QKeySequence("CTRL+Z"));
     undoAction->setToolTip("Undo the last action (not supported by all modules)");
     redoAction = editMenu->addAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-redo.svg"),
       "&Redo",
       QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
       QKeySequence("CTRL+Y"));
     redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
 
     // ==== Window Menu ==========================
     QMenu* windowMenu = menuBar->addMenu("Window");
     if (showNewWindowMenuItem)
     {
       windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
       windowMenu->addSeparator();
     }
 
     QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
 
     QMenu* viewMenu = nullptr;
     if (showViewMenuItem)
     {
       viewMenu = windowMenu->addMenu("Show &View");
       viewMenu->setObjectName("Show View");
     }
     windowMenu->addSeparator();
     resetPerspAction = windowMenu->addAction("&Reset Perspective",
       QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
 
     if(showClosePerspectiveMenuItem)
       closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
 
     windowMenu->addSeparator();
     windowMenu->addAction("&Preferences...",
       QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
       QKeySequence("CTRL+P"));
 
     // fill perspective menu
     berry::IPerspectiveRegistry* perspRegistry =
       window->GetWorkbench()->GetPerspectiveRegistry();
 
     QList<berry::IPerspectiveDescriptor::Pointer> perspectives(
       perspRegistry->GetPerspectives());
 
     skip = false;
     for (QList<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
       perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
     {
       // if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
       // should not appear as an menu-entry in the perspective menu
       if (perspectiveExcludeList.size() > 0)
       {
         for (int i=0; i<perspectiveExcludeList.size(); i++)
         {
           if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
           {
             skip = true;
             break;
           }
         }
         if (skip)
         {
           skip = false;
           continue;
         }
       }
 
       QAction* perspAction = new berry::QtOpenPerspectiveAction(window, *perspIt, perspGroup);
       mapPerspIdToAction.insert((*perspIt)->GetId(), perspAction);
     }
     perspMenu->addActions(perspGroup->actions());
 
     if (showViewMenuItem)
     {
       for (auto viewAction : qAsConst(viewActions))
       {
         viewMenu->addAction(viewAction);
       }
     }
 
     // ===== Help menu ====================================
     QMenu* helpMenu = menuBar->addMenu("&Help");
     helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
     helpMenu->addAction("&Open Help Perspective", this, SLOT(onHelpOpenHelpPerspective()));
     helpMenu->addAction("&Context Help",this, SLOT(onHelp()),  QKeySequence("F1"));
     helpMenu->addAction("&About",this, SLOT(onAbout()));
     // =====================================================
   }
   else
   {
     undoAction = new QmitkUndoAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-undo.svg"), nullptr);
     undoAction->setShortcut(QKeySequence::Undo);
     redoAction = new QmitkRedoAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-redo.svg"), nullptr);
     redoAction->setShortcut(QKeySequence::Redo);
   }
 
   // toolbar for showing file open, undo, redo and other main actions
   auto   mainActionsToolBar = new QToolBar;
   mainActionsToolBar->setObjectName("mainActionsToolBar");
   mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
 #ifdef __APPLE__
   mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
 #else
   mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
 #endif
 
   basePath = QStringLiteral(":/org.mitk.gui.qt.ext/");
   imageNavigatorAction = new QAction(berry::QtStyleManager::ThemeIcon(basePath + "image_navigator.svg"), "&Image Navigator", nullptr);
   bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
 
   if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
   {
     openDicomEditorAction = new QmitkOpenDicomEditorAction(berry::QtStyleManager::ThemeIcon(basePath + "dicom.svg"), window);
   }
   if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
   {
     openStdMultiWidgetEditorAction = new QmitkOpenStdMultiWidgetEditorAction(QIcon(":/org.mitk.gui.qt.ext/Editor.png"), window);
   }
   if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
   {
     openMxNMultiWidgetEditorAction = new QmitkOpenMxNMultiWidgetEditorAction(QIcon(":/org.mitk.gui.qt.ext/Editor.png"), window);
   }
 
   if (imageNavigatorViewFound)
   {
     QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
     imageNavigatorAction->setCheckable(true);
 
     // add part listener for image navigator
     imageNavigatorPartListener.reset(new PartListenerForImageNavigator(imageNavigatorAction));
     window->GetPartService()->AddPartListener(imageNavigatorPartListener.data());
     berry::IViewPart::Pointer imageNavigatorView = window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
     imageNavigatorAction->setChecked(false);
     if (imageNavigatorView)
     {
       bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
       if (isImageNavigatorVisible)
         imageNavigatorAction->setChecked(true);
     }
     imageNavigatorAction->setToolTip("Toggle image navigator for navigating through image");
   }
 
   viewNavigatorAction = new QAction(berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org.mitk.gui.qt.ext/view-manager.svg")),"&View Navigator", nullptr);
   viewNavigatorFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.viewnavigator");
   if (viewNavigatorFound)
   {
     QObject::connect(viewNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onViewNavigator()));
     viewNavigatorAction->setCheckable(true);
 
     // add part listener for view navigator
     viewNavigatorPartListener.reset(new PartListenerForViewNavigator(viewNavigatorAction));
     window->GetPartService()->AddPartListener(viewNavigatorPartListener.data());
     berry::IViewPart::Pointer viewnavigatorview = window->GetActivePage()->FindView("org.mitk.views.viewnavigator");
     viewNavigatorAction->setChecked(false);
     if (viewnavigatorview)
     {
       bool isViewNavigatorVisible = window->GetActivePage()->IsPartVisible(viewnavigatorview);
       if (isViewNavigatorVisible)
         viewNavigatorAction->setChecked(true);
     }
     viewNavigatorAction->setToolTip("Toggle View Navigator");
   }
 
   mainActionsToolBar->addAction(fileOpenAction);
   mainActionsToolBar->addAction(fileSaveProjectAction);
   mainActionsToolBar->addAction(closeProjectAction);
   mainActionsToolBar->addAction(undoAction);
   mainActionsToolBar->addAction(redoAction);
   if(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicombrowser"))
   {
     mainActionsToolBar->addAction(openDicomEditorAction);
   }
   if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.stdmultiwidget"))
   {
     mainActionsToolBar->addAction(openStdMultiWidgetEditorAction);
   }
   if (this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.mxnmultiwidget"))
   {
     mainActionsToolBar->addAction(openMxNMultiWidgetEditorAction);
   }
 
   if (imageNavigatorViewFound)
   {
     mainActionsToolBar->addAction(imageNavigatorAction);
   }
   if (viewNavigatorFound)
   {
     mainActionsToolBar->addAction(viewNavigatorAction);
   }
   mainWindow->addToolBar(mainActionsToolBar);
 
   // ==== Perspective Toolbar ==================================
   auto   qPerspectiveToolbar = new QToolBar;
   qPerspectiveToolbar->setObjectName("perspectiveToolBar");
 
   if (showPerspectiveToolbar)
   {
     qPerspectiveToolbar->addActions(perspGroup->actions());
     mainWindow->addToolBar(qPerspectiveToolbar);
   }
   else
     delete qPerspectiveToolbar;
 
   if (showViewToolbar)
   {
     auto prefService = berry::WorkbenchPlugin::GetDefault()->GetPreferencesService();
     berry::IPreferences::Pointer stylePrefs = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
     bool showCategoryNames = stylePrefs->GetBool(berry::QtPreferences::QT_SHOW_TOOLBAR_CATEGORY_NAMES, true);
 
     // Order view descriptors by category
 
     QMultiMap<QString, berry::IViewDescriptor::Pointer> categoryViewDescriptorMap;
 
     for (const auto &labelViewDescriptorPair : VDMap)
     {
       auto viewDescriptor = labelViewDescriptorPair.second;
       auto category = !viewDescriptor->GetCategoryPath().isEmpty()
         ? viewDescriptor->GetCategoryPath().back()
         : QString();
 
       categoryViewDescriptorMap.insert(category, viewDescriptor);
     }
 
     // Create a separate toolbar for each category
 
     for (const auto &category : categoryViewDescriptorMap.uniqueKeys())
     {
       auto viewDescriptorsInCurrentCategory = categoryViewDescriptorMap.values(category);
 
       if (!viewDescriptorsInCurrentCategory.isEmpty())
       {
         auto toolbar = new QToolBar;
         toolbar->setObjectName(category + " View Toolbar");
         mainWindow->addToolBar(toolbar);
 
         if (showCategoryNames && !category.isEmpty())
         {
           auto categoryButton = new QToolButton;
           categoryButton->setToolButtonStyle(Qt::ToolButtonTextOnly);
           categoryButton->setText(category);
           categoryButton->setStyleSheet("background: transparent; margin: 0; padding: 0;");
           toolbar->addWidget(categoryButton);
 
           connect(categoryButton, &QToolButton::clicked, [toolbar]()
           {
             for (QWidget* widget : toolbar->findChildren<QWidget*>())
             {
               if (QStringLiteral("qt_toolbar_ext_button") == widget->objectName() && widget->isVisible())
               {
                 QMouseEvent pressEvent(QEvent::MouseButtonPress, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                 QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                 QApplication::sendEvent(widget, &pressEvent);
                 QApplication::sendEvent(widget, &releaseEvent);
               }
             }
           });
         }
 
         for (const auto &viewDescriptor : qAsConst(viewDescriptorsInCurrentCategory))
         {
           auto viewAction = new berry::QtShowViewAction(window, viewDescriptor);
           toolbar->addAction(viewAction);
         }
       }
     }
   }
 
   QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
   mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
 
   auto   qStatusBar = new QStatusBar();
 
   //creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
   auto  statusBar = new QmitkStatusBar(qStatusBar);
   //disabling the SizeGrip in the lower right corner
   statusBar->SetSizeGripEnabled(false);
 
   auto  progBar = new QmitkProgressBar();
 
   qStatusBar->addPermanentWidget(progBar, 0);
   progBar->hide();
   // progBar->AddStepsToDo(2);
   // progBar->Progress(1);
 
   mainWindow->setStatusBar(qStatusBar);
 
   if (showMemoryIndicator)
   {
     auto   memoryIndicator = new QmitkMemoryUsageIndicatorView();
     qStatusBar->addPermanentWidget(memoryIndicator, 0);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PreWindowOpen()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
   // show the shortcut bar and progress indicator, which are hidden by
   // default
   //configurer->SetShowPerspectiveBar(true);
   //configurer->SetShowFastViewBars(true);
   //configurer->SetShowProgressIndicator(true);
 
   //  // add the drag and drop support for the editor area
   //  configurer.addEditorAreaTransfer(EditorInputTransfer.getInstance());
   //  configurer.addEditorAreaTransfer(ResourceTransfer.getInstance());
   //  configurer.addEditorAreaTransfer(FileTransfer.getInstance());
   //  configurer.addEditorAreaTransfer(MarkerTransfer.getInstance());
   //  configurer.configureEditorAreaDropListener(new EditorAreaDropAdapter(
   //      configurer.getWindow()));
 
   this->HookTitleUpdateListeners(configurer);
 
   menuPerspectiveListener.reset(new PerspectiveListenerForMenu(this));
   configurer->GetWindow()->AddPerspectiveListener(menuPerspectiveListener.data());
 
   configurer->AddEditorAreaTransfer(QStringList("text/uri-list"));
   configurer->ConfigureEditorAreaDropListener(dropTargetListener.data());
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowOpen()
 {
   berry::WorkbenchWindowAdvisor::PostWindowOpen();
   // Force Rendering Window Creation on startup.
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
   ctkPluginContext* context = QmitkCommonExtPlugin::getContext();
   ctkServiceReference serviceRef = context->getServiceReference<mitk::IDataStorageService>();
   if (serviceRef)
   {
     mitk::IDataStorageService *dsService = context->getService<mitk::IDataStorageService>(serviceRef);
     if (dsService)
     {
       mitk::IDataStorageReference::Pointer dsRef = dsService->GetDataStorage();
       mitk::DataStorageEditorInput::Pointer dsInput(new mitk::DataStorageEditorInput(dsRef));
       mitk::WorkbenchUtil::OpenEditor(configurer->GetWindow()->GetActivePage(),dsInput);
     }
   }
 
   auto introPart = configurer->GetWindow()->GetWorkbench()->GetIntroManager()->GetIntro();
   if (introPart.IsNotNull())
   {
     configurer->GetWindow()->GetWorkbench()->GetIntroManager()->ShowIntro(GetWindowConfigurer()->GetWindow(), false);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onIntro()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onIntro();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onHelp()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelp();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onHelpOpenHelpPerspective()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onHelpOpenHelpPerspective();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::onAbout()
 {
   QmitkExtWorkbenchWindowAdvisorHack::undohack->onAbout();
 }
 
 //--------------------------------------------------------------------------------
 // Ugly hack from here on. Feel free to delete when command framework
 // and undo buttons are done.
 //--------------------------------------------------------------------------------
 
 QmitkExtWorkbenchWindowAdvisorHack::QmitkExtWorkbenchWindowAdvisorHack()
   : QObject()
 {
 }
 
 QmitkExtWorkbenchWindowAdvisorHack::~QmitkExtWorkbenchWindowAdvisorHack()
 {
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onUndo()
 {
   mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
   if (model)
   {
     if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>( model ))
     {
       mitk::VerboseLimitedLinearUndo::StackDescription descriptions = verboseundo->GetUndoDescriptions();
       if (descriptions.size() >= 1)
       {
         MITK_INFO << "Undo " << descriptions.front().second;
       }
     }
     model->Undo();
   }
   else
   {
     MITK_ERROR << "No undo model instantiated";
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onRedo()
 {
   mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
   if (model)
   {
     if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>( model ))
     {
       mitk::VerboseLimitedLinearUndo::StackDescription descriptions = verboseundo->GetRedoDescriptions();
       if (descriptions.size() >= 1)
       {
         MITK_INFO << "Redo " << descriptions.front().second;
       }
     }
     model->Redo();
   }
   else
   {
     MITK_ERROR << "No undo model instantiated";
   }
 }
 
 // safe calls to the complete chain
 // berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->FindView("org.mitk.views.imagenavigator");
 // to cover for all possible cases of closed pages etc.
 static void SafeHandleNavigatorView(QString view_query_name)
 {
   berry::IWorkbench* wbench = berry::PlatformUI::GetWorkbench();
   if( wbench == nullptr )
     return;
 
   berry::IWorkbenchWindow::Pointer wbench_window = wbench->GetActiveWorkbenchWindow();
   if( wbench_window.IsNull() )
     return;
 
   berry::IWorkbenchPage::Pointer wbench_page = wbench_window->GetActivePage();
   if( wbench_page.IsNull() )
     return;
 
   auto wbench_view = wbench_page->FindView( view_query_name );
 
   if( wbench_view.IsNotNull() )
   {
     bool isViewVisible = wbench_page->IsPartVisible( wbench_view );
     if( isViewVisible )
     {
       wbench_page->HideView( wbench_view );
       return;
     }
 
   }
 
   wbench_page->ShowView( view_query_name );
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onImageNavigator()
 {
   // show/hide ImageNavigatorView
   SafeHandleNavigatorView("org.mitk.views.imagenavigator");
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onViewNavigator()
 {
   // show/hide viewnavigatorView
   SafeHandleNavigatorView("org.mitk.views.viewnavigator");
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onEditPreferences()
 {
   QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
   _PreferencesDialog.exec();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onQuit()
 {
   berry::PlatformUI::GetWorkbench()->Close();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onResetPerspective()
 {
   berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onClosePerspective()
 {
   berry::IWorkbenchPage::Pointer page =
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
   page->ClosePerspective(page->GetPerspective(), true, true);
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onNewWindow()
 {
   berry::PlatformUI::GetWorkbench()->OpenWorkbenchWindow(nullptr);
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onIntro()
 {
   bool hasIntro =
     berry::PlatformUI::GetWorkbench()->GetIntroManager()->HasIntro();
   if (!hasIntro)
   {
     QRegExp reg("(.*)<title>(\\n)*");
     QRegExp reg2("(\\n)*</title>(.*)");
     QFile file(":/org.mitk.gui.qt.ext/index.html");
     file.open(QIODevice::ReadOnly | QIODevice::Text); //text file only for reading
 
     QString text = QString(file.readAll());
 
     file.close();
 
     QString title = text;
     title.replace(reg, "");
     title.replace(reg2, "");
 
     std::cout << title.toStdString() << std::endl;
 
     QMessageBox::information(nullptr, title,
       text, "Close");
   }
   else
   {
     berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
       berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow(), false);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onHelp()
 {
   ctkPluginContext* context = QmitkCommonExtPlugin::getContext();
   if (context == nullptr)
   {
     MITK_WARN << "Plugin context not set, unable to open context help";
     return;
   }
 
   // Check if the org.blueberry.ui.qt.help plug-in is installed and started
   QList<QSharedPointer<ctkPlugin> > plugins = context->getPlugins();
   foreach(QSharedPointer<ctkPlugin> p, plugins)
   {
     if (p->getSymbolicName() == "org.blueberry.ui.qt.help")
     {
       if (p->getState() != ctkPlugin::ACTIVE)
       {
         // try to activate the plug-in explicitly
         try
         {
           p->start(ctkPlugin::START_TRANSIENT);
         }
         catch (const ctkPluginException& pe)
         {
           MITK_ERROR << "Activating org.blueberry.ui.qt.help failed: " << pe.what();
           return;
         }
       }
     }
   }
 
   ctkServiceReference eventAdminRef = context->getServiceReference<ctkEventAdmin>();
   ctkEventAdmin* eventAdmin = nullptr;
   if (eventAdminRef)
   {
     eventAdmin = context->getService<ctkEventAdmin>(eventAdminRef);
   }
   if (eventAdmin == nullptr)
   {
     MITK_WARN << "ctkEventAdmin service not found. Unable to open context help";
   }
   else
   {
     ctkEvent ev("org/blueberry/ui/help/CONTEXTHELP_REQUESTED");
     eventAdmin->postEvent(ev);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onHelpOpenHelpPerspective()
 {
   berry::PlatformUI::GetWorkbench()->ShowPerspective("org.blueberry.perspectives.help",
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow());
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onAbout()
 {
   auto aboutDialog = new QmitkAboutDialog(QApplication::activeWindow(),nullptr);
   aboutDialog->open();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::HookTitleUpdateListeners(berry::IWorkbenchWindowConfigurer::Pointer configurer)
 {
   // hook up the listeners to update the window title
   titlePartListener.reset(new PartListenerForTitle(this));
   titlePerspectiveListener.reset(new PerspectiveListenerForTitle(this));
   editorPropertyListener.reset(new berry::PropertyChangeIntAdapter<
     QmitkExtWorkbenchWindowAdvisor>(this,
     &QmitkExtWorkbenchWindowAdvisor::PropertyChange));
 
   //    configurer.getWindow().addPageListener(new IPageListener() {
   //      public void pageActivated(IWorkbenchPage page) {
   //        updateTitle(false);
   //      }
   //
   //      public void pageClosed(IWorkbenchPage page) {
   //        updateTitle(false);
   //      }
   //
   //      public void pageOpened(IWorkbenchPage page) {
   //        // do nothing
   //      }
   //    });
 
   configurer->GetWindow()->AddPerspectiveListener(titlePerspectiveListener.data());
   configurer->GetWindow()->GetPartService()->AddPartListener(titlePartListener.data());
 }
 
 QString QmitkExtWorkbenchWindowAdvisor::ComputeTitle()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   berry::IWorkbenchPage::Pointer currentPage = configurer->GetWindow()->GetActivePage();
   berry::IEditorPart::Pointer activeEditor;
   if (currentPage)
   {
     activeEditor = lastActiveEditor.Lock();
   }
 
   QString title;
   berry::IProduct::Pointer product = berry::Platform::GetProduct();
   if (product.IsNotNull())
   {
     title = product->GetName();
   }
   if (title.isEmpty())
   {
     // instead of the product name, we use a custom variable for now
     title = productName;
   }
 
   if(showMitkVersionInfo)
   {
     QString mitkVersionInfo = MITK_REVISION_DESC;
 
     if(mitkVersionInfo.isEmpty())
       mitkVersionInfo = MITK_VERSION_STRING;
 
     title += " " + mitkVersionInfo;
   }
 
   if (showVersionInfo)
   {
     // add version informatioin
     QString versions = QString(" (ITK %1.%2.%3 | VTK %4.%5.%6 | Qt %7)")
       .arg(ITK_VERSION_MAJOR).arg(ITK_VERSION_MINOR).arg(ITK_VERSION_PATCH)
       .arg(VTK_MAJOR_VERSION).arg(VTK_MINOR_VERSION).arg(VTK_BUILD_VERSION)
       .arg(QT_VERSION_STR);
 
     title += versions;
   }
 
   if (currentPage)
   {
     if (activeEditor)
     {
       lastEditorTitle = activeEditor->GetTitleToolTip();
       if (!lastEditorTitle.isEmpty())
         title = lastEditorTitle + " - " + title;
     }
     berry::IPerspectiveDescriptor::Pointer persp = currentPage->GetPerspective();
     QString label = "";
     if (persp)
     {
       label = persp->GetLabel();
     }
     berry::IAdaptable* input = currentPage->GetInput();
     if (input && input != wbAdvisor->GetDefaultPageInput())
     {
       label = currentPage->GetLabel();
     }
     if (!label.isEmpty())
     {
       title = label + " - " + title;
     }
   }
 
   title += " (Not for use in diagnosis or treatment of patients)";
 
   return title;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::RecomputeTitle()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   QString oldTitle = configurer->GetTitle();
   QString newTitle = ComputeTitle();
   if (newTitle != oldTitle)
   {
     configurer->SetTitle(newTitle);
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::UpdateTitle(bool editorHidden)
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   berry::IWorkbenchWindow::Pointer window = configurer->GetWindow();
   berry::IEditorPart::Pointer activeEditor;
   berry::IWorkbenchPage::Pointer currentPage = window->GetActivePage();
   berry::IPerspectiveDescriptor::Pointer persp;
   berry::IAdaptable* input = nullptr;
 
   if (currentPage)
   {
     activeEditor = currentPage->GetActiveEditor();
     persp = currentPage->GetPerspective();
     input = currentPage->GetInput();
   }
 
   if (editorHidden)
   {
     activeEditor = nullptr;
   }
 
   // Nothing to do if the editor hasn't changed
   if (activeEditor == lastActiveEditor.Lock() && currentPage == lastActivePage.Lock()
     && persp == lastPerspective.Lock() && input == lastInput)
   {
     return;
   }
 
-  if (!lastActiveEditor.Expired())
+  auto lockedLastActiveEditor = lastActiveEditor.Lock();
+
+  if (lockedLastActiveEditor.IsNotNull())
   {
-    lastActiveEditor.Lock()->RemovePropertyListener(editorPropertyListener.data());
+    lockedLastActiveEditor->RemovePropertyListener(editorPropertyListener.data());
   }
 
   lastActiveEditor = activeEditor;
   lastActivePage = currentPage;
   lastPerspective = persp;
   lastInput = input;
 
   if (activeEditor)
   {
     activeEditor->AddPropertyListener(editorPropertyListener.data());
   }
 
   RecomputeTitle();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PropertyChange(const berry::Object::Pointer& /*source*/, int propId)
 {
   if (propId == berry::IWorkbenchPartConstants::PROP_TITLE)
   {
-    if (!lastActiveEditor.Expired())
+    auto lockedLastActiveEditor = lastActiveEditor.Lock();
+
+    if (lockedLastActiveEditor.IsNotNull())
     {
-      QString newTitle = lastActiveEditor.Lock()->GetPartName();
+      QString newTitle = lockedLastActiveEditor->GetPartName();
       if (lastEditorTitle != newTitle)
       {
         RecomputeTitle();
       }
     }
   }
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetPerspectiveExcludeList(const QList<QString>& v)
 {
   this->perspectiveExcludeList = v;
 }
 
 QList<QString> QmitkExtWorkbenchWindowAdvisor::GetPerspectiveExcludeList()
 {
   return this->perspectiveExcludeList;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetViewExcludeList(const QList<QString>& v)
 {
   this->viewExcludeList = v;
 }
 
 QList<QString> QmitkExtWorkbenchWindowAdvisor::GetViewExcludeList()
 {
   return this->viewExcludeList;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowClose()
 {
   berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
   QMainWindow* mainWindow = static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
   settings.setValue("ToolbarPosition", mainWindow->saveState());
 }
 
 QString QmitkExtWorkbenchWindowAdvisor::GetQSettingsFile() const
 {
   QFileInfo settingsInfo = QmitkCommonExtPlugin::getContext()->getDataFile(QT_SETTINGS_FILENAME);
   return settingsInfo.canonicalFilePath();
 }
diff --git a/Plugins/org.mitk.gui.qt.fit.demo/src/internal/FitGeneratorDemoView.h b/Plugins/org.mitk.gui.qt.fit.demo/src/internal/FitGeneratorDemoView.h
index 8bc6f90026..422fc15952 100644
--- a/Plugins/org.mitk.gui.qt.fit.demo/src/internal/FitGeneratorDemoView.h
+++ b/Plugins/org.mitk.gui.qt.fit.demo/src/internal/FitGeneratorDemoView.h
@@ -1,89 +1,87 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef FitGeneratorDemoView_h
 #define FitGeneratorDemoView_h
 
 #include <QString>
 
 #include <QmitkAbstractView.h>
 
 #include <itkCommand.h>
 
 #include "ui_FitGeneratorDemoView.h"
 #include <mitkModelBase.h>
 #include <mitkModelFactoryBase.h>
 #include <QmitkParameterFitBackgroundJob.h>
 #include <mitkModelFitResultHelper.h>
 
 /*!
 *	@brief Test Plugin for generation of model parameter images
 */
 class FitGeneratorDemoView : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   /*! @brief The view's unique ID - required by MITK */
   static const std::string VIEW_ID;
 
   FitGeneratorDemoView();
 
   protected slots:
 
     void OnModellingButtonClicked();
     void OnGenerateTestDataButtonClicked();
     void OnJobFinished();
     void OnJobError(QString err);
     void OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType results, const ParameterFitBackgroundJob* pJob);
     void OnJobProgress(double progress);
     void OnJobStatusChanged(QString info);
 
 protected:
 
   // Overridden base class functions
 
   /*!
   *	@brief					Sets up the UI controls and connects the slots and signals. Gets
   *							called by the framework to create the GUI at the right time.
   *	@param[in,out] parent	The parent QWidget, as this class itself is not a QWidget
   *							subclass.
   */
   void CreateQtPartControl(QWidget* parent) override;
 
   /*!
   *	@brief	Sets the focus to the plot curve button. Gets called by the framework to set the
   *			focus on the right widget.
   */
   void SetFocus() override;
 
   void Generate();
 
-  /*! \brief called by QmitkFunctionality when DataManager's selection has changed
-  */
   void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
     const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::FitGeneratorDemoViewControls m_Controls;
 
   mitk::DataNode::Pointer m_selectedNode;
   mitk::Image::Pointer m_selectedImage;
 
   mitk::DataNode::Pointer m_selectedMaskNode;
   mitk::Image::Pointer m_selectedMask;
 
   mitk::ModelFactoryBase::Pointer m_ModelFactory;
 
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.fit.genericfitting/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.fit.genericfitting/documentation/UserManual/Manual.dox
index 8e7b2a3538..7ecdc6d7f9 100644
--- a/Plugins/org.mitk.gui.qt.fit.genericfitting/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.fit.genericfitting/documentation/UserManual/Manual.dox
@@ -1,70 +1,70 @@
 /**
 \page org_mitk_views_fit_genericfitting The Model Fit Generic Fitting View
 
 \imageMacro{fit_generic_doc.svg,"Icon of the  Generic Fitting View",3.0}
 
 \tableofcontents
 
 \section FIT_GENERIC_Introduction Introduction
 This views offers a generic fitting component for time resolved image data.
 
 \section FIT_GENERIC__Contact Contact information
 If you have any questions, need support, find a bug or have a feature request, feel free to contact us at www.mitk.org.
 
 \subsection FIT_GENERIC__Cite Citation information
 If you use the view for your research please cite our work as reference:\n\n
 Debus C and Floca R, Ingrisch M, Kompan I, Maier-Hein K, Abdollahi A, Nolden M, <i>MITK-ModelFit: generic open-source framework for model fits and their exploration in medical imaging – design, implementation and application on the example of DCE-MRI</i>. https://doi.org/10.1186/s12859-018-2588-1 (BMC Bioinformatics 2019 20:31)
 
 
 \section FIT_GENERIC__Data_and_ROI_Selection Time series and mask selection
 \imageMacro{modelfit_generic_maskAndFittingStrategy.png, "Time series and mask selection.", 10}
 In principle, every model can be fitted on the entire image. However, for model configuration reasons and computational time cost, this is often not advisable.
 Therefore, apart from the image to be fitted (<i>Selected Time Series</i>), a ROI segmentation can be defined (<i>Selected Mask</i>), within which model fitting is performed.
 The view currently offers <i>Pixel based</i> and/or <i>ROI based</i> averaged fits of time-varying curves. The <i>ROI based</i> fitting option becomes enabled, if a mask is selected.
 
 \section FIT_GENERIC_General_models Supported models
 Currently the following models are available for fitting:
 -	<b> Linear model </b>: y = offset + slope*x
 -       <b> Generic parameter model </b>: A simple formula can be manually provided and will be parsed for fitting.
 -       <b> T2 decay model </b>: y = A*exp(-t/B)
 
 
 \section FIT_GENERIC_Settings Model settings
 
-\subsection FIT_DCE_Settings_model Model specific settings
+\subsection FIT_GENERIC_Settings_model Model specific settings
 Selecting one of the \ref FIT_GENERIC_General_models "supported models" will open below tabs for further configuration of the model.
 - The Generic parameter model required as input a formula to be parsed and the number parameters to fit. In the following image, detailed formula information is given.
 \imageMacro{modelfit_generic_genericParamModelSettings.png, "Formula info for the generic parameter model", 10}
 
 \subsection FIT_GENERIC_Settings_start Start parameter
 In cases of noisy data it can be useful to define the initial starting values of the parameter estimates, at which optimization starts, in order to prevent optimization results in local optima.
 Each model has default scalar values (applied to every voxel) for initial values of each parameter, however these can be adjusted.
 Moreover, initial values can also be defined locally for each individual voxel via starting value images. To load a starting value image, change the <i>Type</i> from <i>scalar</i> to <i>image</i>. This can be done by double-clicking on the type cell.
 In the <i>Value</i> column, selection of a starting value image will be available.
 
 \subsection FIT_GENERIC_Settings_constraint Constraints settings
 To limit the fitting search space and to exclude unphysical/illogical results for model parameter estimates, constraints to individual parameters as well as combinations can be imposed.
 Each model has default constraints, however, new ones can be defined or removed by the + and – buttons in the table.
 The first column specifies the parameter(s) involved in the constraint (if multiple parameters are selected, their sum will be used) by selection in the drop down menu.
 The second column <i>Type</i> defines whether the constraint defines an upper or lower boundary.
 <i>Value</i> defines the actual constraint value, that should not be crossed, and <i>Width</i> allows for a certain tolerance width.
 
 
 \section FIT_GENERIC_Fitting Executing a fit
 
 In order to distinguish results from different model fits to the data, a <i>Fitting name</i> can be defined.
 As default, the name of the model and the fitting strategy (pixel/ROI) are given. This name will then be appended by the respective parameter name.\n\n
 
 For development purposes and evaluation of the fits, the option <i>Generate debug parameter images</i> is available.
 Enabling this option will result in additional parameter maps displaying the status of the optimizer at fit termination.
 In the following definitions, an <i>evaluation</i> describes the process of cost function calculation and evaluation by the optimizer for a given parameter set.
 
 - <i>Stop condition</i>: Reasons for the fit termination, i.e. criterion reached, maximum number of iterations,...
 - <i>Optimization time</i>: The overall time from fitting start to termination.
 - <i>Number of iterations</i>: The number of iterations from fitting start to termination.
 
 After all necessary configurations are set, the button <i>Start Modelling</i> is enabled, which starts the fitting routine.
 Progress can be seen in the message box on the bottom. Resulting parameter maps will afterwards be added to the Data Manager as sub-nodes of the analyzed 4D image.
 
 
 */
diff --git a/Plugins/org.mitk.gui.qt.fit.genericfitting/src/internal/GenericDataFittingView.h b/Plugins/org.mitk.gui.qt.fit.genericfitting/src/internal/GenericDataFittingView.h
index 755355ee05..6367d7ece5 100644
--- a/Plugins/org.mitk.gui.qt.fit.genericfitting/src/internal/GenericDataFittingView.h
+++ b/Plugins/org.mitk.gui.qt.fit.genericfitting/src/internal/GenericDataFittingView.h
@@ -1,153 +1,151 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef GenericDataFittingView_h
 #define GenericDataFittingView_h
 
 #include <QString>
 
 #include "QmitkAbstractView.h"
 
 #include "itkCommand.h"
 
 #include "ui_GenericDataFittingViewControls.h"
 #include "mitkModelBase.h"
 #include "QmitkParameterFitBackgroundJob.h"
 #include "mitkModelFitResultHelper.h"
 #include "mitkModelFactoryBase.h"
 #include "mitkLevenbergMarquardtModelFitFunctor.h"
 #include "mitkSimpleBarrierConstraintChecker.h"
 
 #include <mitkNodePredicateBase.h>
 
 /*!
 *	@brief Plugin for generic dynamic image data fitting
 */
 class GenericDataFittingView : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   /*! @brief The view's unique ID - required by MITK */
   static const std::string VIEW_ID;
 
   GenericDataFittingView();
 
 protected slots:
 
   void OnModellingButtonClicked();
 
   void OnJobFinished();
   void OnJobError(QString err);
   void OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType results,
                                 const ParameterFitBackgroundJob* pJob);
   void OnJobProgress(double progress);
   void OnJobStatusChanged(QString info);
 
   void OnModellSet(int);
 
   void OnNrOfParamsChanged();
 
   /**Sets visibility and enabled state of the GUI depending on the settings and workflow state.*/
   void UpdateGUIControls();
 
 protected:
   typedef QList<mitk::DataNode*> SelectedDataNodeVectorType;
 
   // Overridden base class functions
 
   /*!
   *	@brief					Sets up the UI controls and connects the slots and signals. Gets
   *							called by the framework to create the GUI at the right time.
   *	@param[in,out] parent	The parent QWidget, as this class itself is not a QWidget
   *							subclass.
   */
   void CreateQtPartControl(QWidget* parent) override;
 
   /*!
   *	@brief	Sets the focus to the plot curve button. Gets called by the framework to set the
   *			focus on the right widget.
   */
   void SetFocus() override;
 
   template <typename TParameterizer>
   void GenerateModelFit_ROIBased(mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
                                  mitk::ParameterFitImageGeneratorBase::Pointer& generator);
 
   template <typename TParameterizer>
   void GenerateModelFit_PixelBased(mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
                                    mitk::ParameterFitImageGeneratorBase::Pointer& generator);
 
   /** Helper function that configures the initial parameter strategy of a parameterizer
    according to the settings of the GUI.*/
   void ConfigureInitialParametersOfParameterizer(mitk::ModelParameterizerBase* parameterizer) const;
 
   void PrepareFitConfiguration();
 
   bool IsGenericParamFactorySelected() const;
 
   /*! Starts the fitting job with the passed generator and session info*/
   void DoFit(const mitk::modelFit::ModelFitInfo* fitSession,
              mitk::ParameterFitImageGeneratorBase* generator);
 
   /**Checks if the settings in the GUI are valid for the chosen model.*/
   bool CheckModelSettings() const;
 
   void InitModelComboBox() const;
 
-  /*! \brief called by QmitkFunctionality when DataManager's selection has changed
-  */
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
                                   const QList<mitk::DataNode::Pointer>& selectedNodes) override;
 
   // Variables
 
   /*! @brief The view's UI controls */
   Ui::GeneralDataFittingViewControls m_Controls;
 
   /* Nodes selected by user/ui for the fit */
   mitk::DataNode::Pointer m_selectedNode;
   mitk::DataNode::Pointer m_selectedMaskNode;
 
   /* Images selected by user/ui for the fit */
   mitk::Image::Pointer m_selectedImage;
   mitk::Image::Pointer m_selectedMask;
 
   mitk::ModelFactoryBase::Pointer m_selectedModelFactory;
 
   mitk::SimpleBarrierConstraintChecker::Pointer m_modelConstraints;
 
 private:
 
   bool m_FittingInProgress;
 
   typedef std::vector<mitk::ModelFactoryBase::Pointer> ModelFactoryStackType;
   ModelFactoryStackType m_FactoryStack;
 
   /**Helper function that generates a default fitting functor
    * default is a levenberg marquart based optimizer with all scales set to 1.0.
    * Constraint setter will be set based on the gui setting and a evaluation parameter
    * "sum of squared differences" will always be set.*/
   mitk::ModelFitFunctorBase::Pointer CreateDefaultFitFunctor(const mitk::ModelParameterizerBase*
       parameterizer) const;
 
   /**Returns the default fit name, derived from the current GUI settings.*/
   std::string GetDefaultFitName() const;
   /**Returns the current set name of the fit (either default name or use defined name).*/
   std::string GetFitName() const;
 
   mitk::NodePredicateBase::Pointer m_IsNotABinaryImagePredicate;
   mitk::NodePredicateBase::Pointer m_IsBinaryImagePredicate;
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/org_mitk_gui_qt_fit_inspector_Activator.h b/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/org_mitk_gui_qt_fit_inspector_Activator.h
index a2e404a0a4..3b0a0fe8d2 100644
--- a/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/org_mitk_gui_qt_fit_inspector_Activator.h
+++ b/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/org_mitk_gui_qt_fit_inspector_Activator.h
@@ -1,32 +1,32 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef org_mitk_gui_qt_fit_inspector_Activator_h
 #define org_mitk_gui_qt_fit_inspector_Activator_h
 
 #include <ctkPluginActivator.h>
 
 
     class org_mitk_gui_qt_fit_inspector_Activator : public QObject, public ctkPluginActivator
     {
     Q_OBJECT
-      Q_PLUGIN_METADATA(IID "org_mitk_guit_qt_fit_inspector")
+      Q_PLUGIN_METADATA(IID "org_mitk_gui_qt_fit_inspector")
       Q_INTERFACES(ctkPluginActivator)
     public:
 
         void start(ctkPluginContext* context) override;
         void stop(ctkPluginContext* context) override;
 
     }; // org_mitk_modelfit_visualization_Activator
 
 #endif // org_mitk_modelfit_visualization_Activator_h
diff --git a/Plugins/org.mitk.gui.qt.flow.segmentation/src/internal/QmitkSegmentationFlowControlView.cpp b/Plugins/org.mitk.gui.qt.flow.segmentation/src/internal/QmitkSegmentationFlowControlView.cpp
index 4027f2b176..bc674b04d4 100644
--- a/Plugins/org.mitk.gui.qt.flow.segmentation/src/internal/QmitkSegmentationFlowControlView.cpp
+++ b/Plugins/org.mitk.gui.qt.flow.segmentation/src/internal/QmitkSegmentationFlowControlView.cpp
@@ -1,126 +1,104 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "org_mitk_gui_qt_flow_segmentation_Activator.h"
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 #include <itksys/SystemTools.hxx>
 
 //MITK
-#include "mitkLabelSetImage.h"
-#include "mitkNodePredicateAnd.h"
-#include "mitkNodePredicateNot.h"
-#include "mitkNodePredicateProperty.h"
-#include "mitkNodePredicateDataType.h"
-#include "mitkIOUtil.h"
+#include <mitkBaseApplication.h>
+#include <mitkLabelSetImage.h>
+#include <mitkNodePredicateAnd.h>
+#include <mitkNodePredicateNot.h>
+#include <mitkNodePredicateProperty.h>
+#include <mitkNodePredicateDataType.h>
+#include <mitkIOUtil.h>
 
 // Qmitk
 #include "QmitkSegmentationFlowControlView.h"
 
 // Qt
 #include <QMessageBox>
 #include <QDir>
 
 const std::string QmitkSegmentationFlowControlView::VIEW_ID = "org.mitk.views.flow.control";
 
 QmitkSegmentationFlowControlView::QmitkSegmentationFlowControlView()
     : m_Parent(nullptr)
 {
   auto nodePredicate = mitk::NodePredicateAnd::New();
   nodePredicate->AddPredicate(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   nodePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   m_SegmentationPredicate = nodePredicate;
-
-  m_OutputDir = QString::fromStdString(itksys::SystemTools::GetCurrentWorkingDirectory());
-  m_FileExtension = "nrrd";
 }
 
 void QmitkSegmentationFlowControlView::SetFocus()
 {
     m_Controls.btnStoreAndAccept->setFocus();
 }
 
 void QmitkSegmentationFlowControlView::CreateQtPartControl(QWidget* parent)
 {
-    // create GUI widgets from the Qt Designer's .ui file
-    m_Controls.setupUi(parent);
-
-    m_Parent = parent;
-
-    connect(m_Controls.btnStoreAndAccept, SIGNAL(clicked()), this, SLOT(OnAcceptButtonPushed()));
-
-    m_Controls.labelStored->setVisible(false);
-    UpdateControls();
-
-    auto arguments = QCoreApplication::arguments();
-
-    bool isFlagFound = false;
-    for (auto arg : arguments)
-    {
-      if (isFlagFound)
-      {
-        m_OutputDir = arg;
-        break;
-      }
-      isFlagFound = arg.startsWith("--flow.outputdir");
-    }
-    isFlagFound = false;
-    for (auto arg : arguments)
-    {
-      if (isFlagFound)
-      {
-        m_FileExtension = arg;
-        break;
-      }
-      isFlagFound = arg.startsWith("--flow.outputextension");
-    }
-
-    m_OutputDir = QDir::fromNativeSeparators(m_OutputDir);
+  // create GUI widgets from the Qt Designer's .ui file
+  m_Controls.setupUi(parent);
+
+  m_Parent = parent;
+
+  connect(m_Controls.btnStoreAndAccept, SIGNAL(clicked()), this, SLOT(OnAcceptButtonPushed()));
+
+  m_Controls.labelStored->setVisible(false);
+  UpdateControls();
+
+  m_OutputDir = QString::fromStdString(mitk::BaseApplication::instance().config().getString("flow.outputdir", itksys::SystemTools::GetCurrentWorkingDirectory()));
+  m_OutputDir = QDir::fromNativeSeparators(m_OutputDir);
+
+  m_FileExtension = QString::fromStdString(mitk::BaseApplication::instance().config().getString("flow.outputextension", "nrrd"));
 }
 
 void QmitkSegmentationFlowControlView::OnAcceptButtonPushed()
 {
   auto nodes = this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
 
   for (auto node : *nodes)
   {
     QString outputpath = m_OutputDir + "/" + QString::fromStdString(node->GetName()) + "." + m_FileExtension;
     outputpath = QDir::toNativeSeparators(QDir::cleanPath(outputpath));
     mitk::IOUtil::Save(node->GetData(), outputpath.toStdString());
   }
 
   m_Controls.labelStored->setVisible(true);
 }
 
 void QmitkSegmentationFlowControlView::UpdateControls()
 {
   auto nodes = this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
   m_Controls.btnStoreAndAccept->setEnabled(!nodes->empty());
 };
 
 void QmitkSegmentationFlowControlView::NodeAdded(const mitk::DataNode* /*node*/)
 {
   UpdateControls();
 };
 
 void QmitkSegmentationFlowControlView::NodeChanged(const mitk::DataNode* /*node*/)
 {
   UpdateControls();
 };
 
 void QmitkSegmentationFlowControlView::NodeRemoved(const mitk::DataNode* /*node*/)
 {
   UpdateControls();
 };
diff --git a/Plugins/org.mitk.gui.qt.flowapplication/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.flowapplication/manifest_headers.cmake
index 0892740d80..d1227975c7 100644
--- a/Plugins/org.mitk.gui.qt.flowapplication/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.flowapplication/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Flow Application")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "DKFZ, Medical Image Computing")
 set(Plugin-ContactAddress "http://www.mitk.org")
-set(Require-Plugin org.mitk.core.ext org.mitk.gui.qt.application)
+set(Require-Plugin org.mitk.gui.qt.ext)
diff --git a/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationPlugin.cpp b/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationPlugin.cpp
index 11a5a20215..cd487ca748 100644
--- a/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationPlugin.cpp
+++ b/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationPlugin.cpp
@@ -1,203 +1,199 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkFlowApplicationPlugin.h"
 #include "QmitkFlowApplication.h"
 
 #include <service/cm/ctkConfigurationAdmin.h>
 #include <service/cm/ctkConfiguration.h>
 
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIPreferencesService.h>
 #include <berryIPreferences.h>
 
 #include <mitkVersion.h>
 #include <mitkLogMacros.h>
 
 #include <mitkIDataStorageService.h>
 #include <mitkSceneIO.h>
 #include <mitkProgressBar.h>
 #include <mitkRenderingManager.h>
 #include <mitkIOUtil.h>
 
 #include <QtWidgetsExtRegisterClasses.h>
 
 #include <QProcess>
 #include <QMainWindow>
 #include <QCoreApplication>
 
 
 QmitkFlowApplicationPlugin* QmitkFlowApplicationPlugin::inst = nullptr;
 
 QmitkFlowApplicationPlugin::QmitkFlowApplicationPlugin()
 {
   inst = this;
 }
 
 QmitkFlowApplicationPlugin::~QmitkFlowApplicationPlugin()
 {
 }
 
 QmitkFlowApplicationPlugin* QmitkFlowApplicationPlugin::GetDefault()
 {
   return inst;
 }
 
 void QmitkFlowApplicationPlugin::start(ctkPluginContext* context)
 {
   berry::AbstractUICTKPlugin::start(context);
 
   this->_context = context;
 
   QtWidgetsExtRegisterClasses();
 
   BERRY_REGISTER_EXTENSION_CLASS(QmitkFlowApplication, context);
 
   ctkServiceReference cmRef = context->getServiceReference<ctkConfigurationAdmin>();
   ctkConfigurationAdmin* configAdmin = nullptr;
   if (cmRef)
   {
     configAdmin = context->getService<ctkConfigurationAdmin>(cmRef);
   }
 
   // Use the CTK Configuration Admin service to configure the BlueBerry help system
   if (configAdmin)
   {
     ctkConfigurationPtr conf = configAdmin->getConfiguration("org.blueberry.services.help", QString());
     ctkDictionary helpProps;
     helpProps.insert("homePage", "qthelp://org.mitk.gui.qt.flowapplication/bundle/index.html");
     conf->update(helpProps);
     context->ungetService(cmRef);
   }
   else
   {
     MITK_WARN << "Configuration Admin service unavailable, cannot set home page url.";
   }
 
   if (qApp->metaObject()->indexOfSignal("messageReceived(QByteArray)") > -1)
   {
     connect(qApp, SIGNAL(messageReceived(QByteArray)), this, SLOT(handleIPCMessage(QByteArray)));
   }
 
   // This is a potentially long running operation.
   loadDataFromDisk(berry::Platform::GetApplicationArgs(), true);
 }
 
 void QmitkFlowApplicationPlugin::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 
     this->_context = nullptr;
 }
 
 ctkPluginContext* QmitkFlowApplicationPlugin::GetPluginContext() const
 {
   return _context;
 }
 
 void QmitkFlowApplicationPlugin::loadDataFromDisk(const QStringList &arguments, bool globalReinit)
 {
   if (!arguments.empty())
   {
     ctkServiceReference serviceRef = _context->getServiceReference<mitk::IDataStorageService>();
     if (serviceRef)
     {
       mitk::IDataStorageService* dataStorageService = _context->getService<mitk::IDataStorageService>(serviceRef);
       mitk::DataStorage::Pointer dataStorage = dataStorageService->GetDefaultDataStorage()->GetDataStorage();
 
       int argumentsAdded = 0;
       for (int i = 0; i < arguments.size(); ++i)
       {
-        if (arguments[i].startsWith("--flow."))
-        { //By convention no further files are specified as soon as a flow arguments comes.
-          break;
-        }
-        else if (arguments[i].right(5) == ".mitk")
+        if (arguments[i].right(5) == ".mitk")
         {
           mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
 
           bool clearDataStorageFirst(false);
           mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
           dataStorage = sceneIO->LoadScene(arguments[i].toLocal8Bit().constData(), dataStorage, clearDataStorageFirst);
           mitk::ProgressBar::GetInstance()->Progress(2);
           argumentsAdded++;
         }
         else if (arguments[i].right(15) == ".mitksceneindex")
         {
           mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
 
           bool clearDataStorageFirst(false);
           mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
           dataStorage = sceneIO->LoadSceneUnzipped(arguments[i].toLocal8Bit().constData(), dataStorage, clearDataStorageFirst);
           mitk::ProgressBar::GetInstance()->Progress(2);
           argumentsAdded++;
         }
         else
         {
           try
           {
             const std::string path(arguments[i].toStdString());
             auto addedNodes = mitk::IOUtil::Load(path, *dataStorage);
 
             for (const auto& node : *addedNodes)
             {
               node->SetIntProperty("layer", argumentsAdded);
             }
 
             argumentsAdded++;
           }
           catch (...)
           {
             MITK_WARN << "Failed to load command line argument: " << arguments[i].toStdString();
           }
         }
       } // end for each command line argument
 
       if (argumentsAdded > 0 && globalReinit)
       {
         // calculate bounding geometry
         mitk::RenderingManager::GetInstance()->InitializeViews(dataStorage->ComputeBoundingGeometry3D());
       }
     }
     else
     {
       MITK_ERROR << "A service reference for mitk::IDataStorageService does not exist";
     }
   }
 }
 
 void QmitkFlowApplicationPlugin::handleIPCMessage(const QByteArray& msg)
 {
   QDataStream ds(msg);
   QString msgType;
   ds >> msgType;
 
   // we only handle messages containing command line arguments
   if (msgType != "$cmdLineArgs") return;
 
   // activate the current workbench window
   berry::IWorkbenchWindow::Pointer window =
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow();
 
   QMainWindow* mainWindow =
     static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   mainWindow->setWindowState(mainWindow->windowState() & ~Qt::WindowMinimized);
   mainWindow->raise();
   mainWindow->activateWindow();
 
   QStringList args;
   ds >> args;
 
   loadDataFromDisk(args, false);
 }
diff --git a/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisor.cpp b/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisor.cpp
index 710e4ebd81..e13edad78c 100644
--- a/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisor.cpp
+++ b/Plugins/org.mitk.gui.qt.flowapplication/src/internal/QmitkFlowApplicationWorkbenchWindowAdvisor.cpp
@@ -1,1145 +1,1151 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #include "QmitkFlowApplicationWorkbenchWindowAdvisor.h"
 
 #include <QMenu>
 #include <QMenuBar>
 #include <QMainWindow>
 #include <QStatusBar>
 #include <QString>
 #include <QFile>
 #include <QRegExp>
 #include <QTextStream>
 #include <QSettings>
 
 #include <ctkPluginException.h>
 #include <service/event/ctkEventAdmin.h>
 
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIActionBarConfigurer.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryIPerspectiveDescriptor.h>
 #include <berryIProduct.h>
 #include <berryIWorkbenchPartConstants.h>
 #include <berryQtPreferences.h>
 #include <berryQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 #include <berryIPreferences.h>
 
 #include <internal/berryQtShowViewAction.h>
 #include <internal/berryQtOpenPerspectiveAction.h>
 
 #include <QmitkFileExitAction.h>
 #include <QmitkCloseProjectAction.h>
 #include <QmitkUndoAction.h>
 #include <QmitkRedoAction.h>
 #include <QmitkDefaultDropTargetListener.h>
 #include <QmitkStatusBar.h>
 #include <QmitkProgressBar.h>
 #include <QmitkMemoryUsageIndicatorView.h>
 #include <QmitkPreferencesDialog.h>
 #include "QmitkExtFileSaveProjectAction.h"
 
 #include <itkConfigure.h>
 #include <mitkVersion.h>
 #include <mitkIDataStorageService.h>
 #include <mitkIDataStorageReference.h>
 #include <mitkDataStorageEditorInput.h>
 #include <mitkWorkbenchUtil.h>
 #include <vtkVersionMacros.h>
 
 // UGLYYY
 #include "QmitkFlowApplicationWorkbenchWindowAdvisorHack.h"
 #include "QmitkFlowApplicationPlugin.h"
 #include "mitkUndoController.h"
 #include "mitkVerboseLimitedLinearUndo.h"
 #include <QToolBar>
 #include <QToolButton>
 #include <QMessageBox>
 #include <QMouseEvent>
 #include <QLabel>
 #include <QmitkAboutDialog.h>
 
 QmitkFlowApplicationWorkbenchWindowAdvisorHack* QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack =
   new QmitkFlowApplicationWorkbenchWindowAdvisorHack();
 
 QString QmitkFlowApplicationWorkbenchWindowAdvisor::QT_SETTINGS_FILENAME = "QtSettings.ini";
 
 class PartListenerForTitle: public berry::IPartListener
 {
 public:
 
   PartListenerForTitle(QmitkFlowApplicationWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
   {
   }
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::ACTIVATED | Events::BROUGHT_TO_TOP | Events::CLOSED
       | Events::HIDDEN | Events::VISIBLE;
   }
 
   void PartActivated(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref.Cast<berry::IEditorReference> ())
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
   void PartBroughtToTop(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref.Cast<berry::IEditorReference> ())
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& /*ref*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
-    if (!windowAdvisor->lastActiveEditor.Expired() &&
-      ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
+    auto lockedLastActiveEditor = windowAdvisor->lastActiveEditor.Lock();
+
+    if (lockedLastActiveEditor.IsNotNull() && ref->GetPart(false) == lockedLastActiveEditor)
     {
       windowAdvisor->UpdateTitle(true);
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
-    if (!windowAdvisor->lastActiveEditor.Expired() &&
-      ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
+    auto lockedLastActiveEditor = windowAdvisor->lastActiveEditor.Lock();
+
+    if (lockedLastActiveEditor.IsNotNull() && ref->GetPart(false) == lockedLastActiveEditor)
     {
       windowAdvisor->UpdateTitle(false);
     }
   }
 
 private:
   QmitkFlowApplicationWorkbenchWindowAdvisor* windowAdvisor;
 };
 
 class PartListenerForImageNavigator: public berry::IPartListener
 {
 public:
 
   PartListenerForImageNavigator(QAction* act)
     : imageNavigatorAction(act)
   {
   }
 
   Events::Types GetPartEventTypes() const override
   {
     return Events::OPENED | Events::CLOSED | Events::HIDDEN |
       Events::VISIBLE;
   }
 
   void PartOpened(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(true);
     }
   }
 
   void PartClosed(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(false);
     }
   }
 
   void PartVisible(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(true);
     }
   }
 
   void PartHidden(const berry::IWorkbenchPartReference::Pointer& ref) override
   {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
       imageNavigatorAction->setChecked(false);
     }
   }
 
 private:
   QAction* imageNavigatorAction;
 };
 
 class PerspectiveListenerForTitle: public berry::IPerspectiveListener
 {
 public:
 
   PerspectiveListenerForTitle(QmitkFlowApplicationWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
     , perspectivesClosed(false)
   {
   }
 
   Events::Types GetPerspectiveEventTypes() const override
   {
     return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED
       | Events::CLOSED | Events::OPENED;
   }
 
   void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveSavedAs(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*oldPerspective*/,
     const berry::IPerspectiveDescriptor::Pointer& /*newPerspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     windowAdvisor->UpdateTitle(false);
   }
 
   void PerspectiveOpened(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     if (perspectivesClosed)
     {
       QListIterator<QAction*> i(windowAdvisor->viewActions);
       while (i.hasNext())
       {
         i.next()->setEnabled(true);
       }
 
       windowAdvisor->fileSaveProjectAction->setEnabled(true);
       windowAdvisor->undoAction->setEnabled(true);
       windowAdvisor->redoAction->setEnabled(true);
       windowAdvisor->imageNavigatorAction->setEnabled(true);
       windowAdvisor->resetPerspAction->setEnabled(true);
     }
 
     perspectivesClosed = false;
   }
 
   void PerspectiveClosed(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& /*perspective*/) override
   {
     berry::IWorkbenchWindow::Pointer wnd = windowAdvisor->GetWindowConfigurer()->GetWindow();
     bool allClosed = true;
     if (wnd->GetActivePage())
     {
       QList<berry::IPerspectiveDescriptor::Pointer> perspectives(wnd->GetActivePage()->GetOpenPerspectives());
       allClosed = perspectives.empty();
     }
 
     if (allClosed)
     {
       perspectivesClosed = true;
 
       QListIterator<QAction*> i(windowAdvisor->viewActions);
       while (i.hasNext())
       {
         i.next()->setEnabled(false);
       }
 
       windowAdvisor->fileSaveProjectAction->setEnabled(false);
       windowAdvisor->undoAction->setEnabled(false);
       windowAdvisor->redoAction->setEnabled(false);
       windowAdvisor->imageNavigatorAction->setEnabled(false);
       windowAdvisor->resetPerspAction->setEnabled(false);
     }
   }
 
 private:
   QmitkFlowApplicationWorkbenchWindowAdvisor* windowAdvisor;
   bool perspectivesClosed;
 };
 
 class PerspectiveListenerForMenu: public berry::IPerspectiveListener
 {
 public:
 
   PerspectiveListenerForMenu(QmitkFlowApplicationWorkbenchWindowAdvisor* wa)
     : windowAdvisor(wa)
   {
   }
 
   Events::Types GetPerspectiveEventTypes() const override
   {
     return Events::ACTIVATED | Events::DEACTIVATED;
   }
 
   void PerspectiveActivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& perspective) override
   {
     QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
     if (action)
     {
       action->setChecked(true);
     }
   }
 
   void PerspectiveDeactivated(const berry::IWorkbenchPage::Pointer& /*page*/,
     const berry::IPerspectiveDescriptor::Pointer& perspective) override
   {
     QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
     if (action)
     {
       action->setChecked(false);
     }
   }
 
 private:
   QmitkFlowApplicationWorkbenchWindowAdvisor* windowAdvisor;
 };
 
 QmitkFlowApplicationWorkbenchWindowAdvisor::QmitkFlowApplicationWorkbenchWindowAdvisor(berry::WorkbenchAdvisor* wbAdvisor,
                                                                berry::IWorkbenchWindowConfigurer::Pointer configurer)
   : berry::WorkbenchWindowAdvisor(configurer)
   , lastInput(nullptr)
   , wbAdvisor(wbAdvisor)
   , showViewToolbar(true)
   , showVersionInfo(true)
   , showMitkVersionInfo(true)
   , showMemoryIndicator(true)
   , dropTargetListener(new QmitkDefaultDropTargetListener)
 {
   productName = QCoreApplication::applicationName();
   viewExcludeList.push_back("org.mitk.views.viewnavigator");
 }
 
 QmitkFlowApplicationWorkbenchWindowAdvisor::~QmitkFlowApplicationWorkbenchWindowAdvisor()
 {
 }
 
 QWidget* QmitkFlowApplicationWorkbenchWindowAdvisor::CreateEmptyWindowContents(QWidget* parent)
 {
   QWidget* parentWidget = static_cast<QWidget*>(parent);
   auto   label = new QLabel(parentWidget);
   label->setText("<b>No perspectives are open. Open a perspective in the <i>Window->Open Perspective</i> menu.</b>");
   label->setContentsMargins(10,10,10,10);
   label->setAlignment(Qt::AlignTop);
   label->setEnabled(false);
   parentWidget->layout()->addWidget(label);
   return label;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::ShowMemoryIndicator(bool show)
 {
   showMemoryIndicator = show;
 }
 
 bool QmitkFlowApplicationWorkbenchWindowAdvisor::GetShowMemoryIndicator()
 {
   return showMemoryIndicator;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::ShowViewToolbar(bool show)
 {
   showViewToolbar = show;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::ShowVersionInfo(bool show)
 {
   showVersionInfo = show;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::ShowMitkVersionInfo(bool show)
 {
   showMitkVersionInfo = show;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::SetProductName(const QString& product)
 {
   productName = product;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::SetWindowIcon(const QString& wndIcon)
 {
   windowIcon = wndIcon;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::PostWindowCreate()
 {
   // very bad hack...
   berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
   QMainWindow* mainWindow = qobject_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   if (!windowIcon.isEmpty())
   {
     mainWindow->setWindowIcon(QIcon(windowIcon));
   }
   mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
 
   // Load icon theme
   QIcon::setThemeSearchPaths(QStringList() << QStringLiteral(":/org_mitk_icons/icons/"));
   QIcon::setThemeName(QStringLiteral("awesome"));
 
   // ==== Application menu ============================
 
   QMenuBar* menuBar = mainWindow->menuBar();
   menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
 
 #ifdef __APPLE__
   menuBar->setNativeMenuBar(true);
 #else
   menuBar->setNativeMenuBar(false);
 #endif
 
   auto basePath = QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/");
 
   fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
   fileSaveProjectAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "document-save.svg"));
 
   auto   perspGroup = new QActionGroup(menuBar);
   std::map<QString, berry::IViewDescriptor::Pointer> VDMap;
 
   // sort elements (converting vector to map...)
   QList<berry::IViewDescriptor::Pointer>::const_iterator iter;
 
   berry::IViewRegistry* viewRegistry =
     berry::PlatformUI::GetWorkbench()->GetViewRegistry();
   const QList<berry::IViewDescriptor::Pointer> viewDescriptors = viewRegistry->GetViews();
 
   bool skip = false;
   for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
   {
     // if viewExcludeList is set, it contains the id-strings of view, which
     // should not appear as an menu-entry in the menu
     if (viewExcludeList.size() > 0)
     {
       for (int i=0; i<viewExcludeList.size(); i++)
       {
         if (viewExcludeList.at(i) == (*iter)->GetId())
         {
           skip = true;
           break;
         }
       }
       if (skip)
       {
         skip = false;
         continue;
       }
     }
 
     if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
       continue;
     if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
       continue;
     if ((*iter)->GetId() == "org.mitk.views.viewnavigator")
       continue;
 
     std::pair<QString, berry::IViewDescriptor::Pointer> p((*iter)->GetLabel(), (*iter));
     VDMap.insert(p);
   }
 
   std::map<QString, berry::IViewDescriptor::Pointer>::const_iterator MapIter;
   for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
   {
     berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window, (*MapIter).second);
     viewActions.push_back(viewAction);
   }
 
   QMenu* fileMenu = menuBar->addMenu("&File");
   fileMenu->setObjectName("FileMenu");
   fileMenu->addAction(fileSaveProjectAction);
   fileMenu->addSeparator();
 
   QAction* fileExitAction = new QmitkFileExitAction(window);
   fileExitAction->setIcon(berry::QtStyleManager::ThemeIcon(basePath + "system-log-out.svg"));
   fileExitAction->setShortcut(QKeySequence::Quit);
   fileExitAction->setObjectName("QmitkFileExitAction");
   fileMenu->addAction(fileExitAction);
 
   // another bad hack to get an edit/undo menu...
   QMenu* editMenu = menuBar->addMenu("&Edit");
   undoAction = editMenu->addAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-undo.svg"),
     "&Undo",
     QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
     QKeySequence("CTRL+Z"));
   undoAction->setToolTip("Undo the last action (not supported by all modules)");
   redoAction = editMenu->addAction(berry::QtStyleManager::ThemeIcon(basePath + "edit-redo.svg"),
     "&Redo",
     QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
     QKeySequence("CTRL+Y"));
   redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
 
   // ==== Window Menu ==========================
   QMenu* windowMenu = menuBar->addMenu("Window");
 
   QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
 
   windowMenu->addSeparator();
   resetPerspAction = windowMenu->addAction("&Reset Perspective",
     QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
 
   windowMenu->addSeparator();
   windowMenu->addAction("&Preferences...",
     QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
     QKeySequence("CTRL+P"));
 
   // fill perspective menu
   berry::IPerspectiveRegistry* perspRegistry =
     window->GetWorkbench()->GetPerspectiveRegistry();
 
   QList<berry::IPerspectiveDescriptor::Pointer> perspectives(
     perspRegistry->GetPerspectives());
 
   skip = false;
   for (QList<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
     perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
   {
     // if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
     // should not appear as an menu-entry in the perspective menu
     if (perspectiveExcludeList.size() > 0)
     {
       for (int i=0; i<perspectiveExcludeList.size(); i++)
       {
         if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
         {
           skip = true;
           break;
         }
       }
       if (skip)
       {
         skip = false;
         continue;
       }
     }
 
     QAction* perspAction = new berry::QtOpenPerspectiveAction(window, *perspIt, perspGroup);
     mapPerspIdToAction.insert((*perspIt)->GetId(), perspAction);
   }
   perspMenu->addActions(perspGroup->actions());
 
   // ===== Help menu ====================================
   QMenu* helpMenu = menuBar->addMenu("&Help");
   helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
   helpMenu->addAction("&Open Help Perspective", this, SLOT(onHelpOpenHelpPerspective()));
   helpMenu->addAction("&Context Help",this, SLOT(onHelp()),  QKeySequence("F1"));
   helpMenu->addAction("&About",this, SLOT(onAbout()));
   // =====================================================
 
 
   // toolbar for showing file open, undo, redo and other main actions
   auto   mainActionsToolBar = new QToolBar;
   mainActionsToolBar->setObjectName("mainActionsToolBar");
   mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
 #ifdef __APPLE__
   mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
 #else
   mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
 #endif
 
   basePath = QStringLiteral(":/org.mitk.gui.qt.ext/");
   imageNavigatorAction = new QAction(berry::QtStyleManager::ThemeIcon(basePath + "image_navigator.svg"), "&Image Navigator", nullptr);
   bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
 
   if (imageNavigatorViewFound)
   {
     QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
     imageNavigatorAction->setCheckable(true);
 
     // add part listener for image navigator
     imageNavigatorPartListener.reset(new PartListenerForImageNavigator(imageNavigatorAction));
     window->GetPartService()->AddPartListener(imageNavigatorPartListener.data());
     berry::IViewPart::Pointer imageNavigatorView = window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
     imageNavigatorAction->setChecked(false);
     if (imageNavigatorView)
     {
       bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
       if (isImageNavigatorVisible)
         imageNavigatorAction->setChecked(true);
     }
     imageNavigatorAction->setToolTip("Toggle image navigator for navigating through image");
   }
 
   mainActionsToolBar->addAction(undoAction);
   mainActionsToolBar->addAction(redoAction);
 
   if (imageNavigatorViewFound)
   {
     mainActionsToolBar->addAction(imageNavigatorAction);
   }
 
   mainWindow->addToolBar(mainActionsToolBar);
 
   // ==== View Toolbar ==================================
 
   if (showViewToolbar)
   {
     auto prefService = berry::WorkbenchPlugin::GetDefault()->GetPreferencesService();
     berry::IPreferences::Pointer stylePrefs = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
     bool showCategoryNames = stylePrefs->GetBool(berry::QtPreferences::QT_SHOW_TOOLBAR_CATEGORY_NAMES, true);
 
     // Order view descriptors by category
 
     QMultiMap<QString, berry::IViewDescriptor::Pointer> categoryViewDescriptorMap;
 
     for (auto labelViewDescriptorPair : VDMap)
     {
       auto viewDescriptor = labelViewDescriptorPair.second;
       auto category = !viewDescriptor->GetCategoryPath().isEmpty()
         ? viewDescriptor->GetCategoryPath().back()
         : QString();
 
       categoryViewDescriptorMap.insert(category, viewDescriptor);
     }
 
     // Create a separate toolbar for each category
 
     for (auto category : categoryViewDescriptorMap.uniqueKeys())
     {
       auto viewDescriptorsInCurrentCategory = categoryViewDescriptorMap.values(category);
       QList<berry::SmartPointer<berry::IViewDescriptor> > relevantViewDescriptors;
 
       for (auto viewDescriptor : viewDescriptorsInCurrentCategory)
       {
         if (viewDescriptor->GetId() != "org.mitk.views.flow.control")
         {
           relevantViewDescriptors.push_back(viewDescriptor);
         }
       }
 
       if (!relevantViewDescriptors.isEmpty())
       {
         auto toolbar = new QToolBar;
         toolbar->setObjectName(category + " View Toolbar");
         mainWindow->addToolBar(toolbar);
 
         if (showCategoryNames && !category.isEmpty())
         {
           auto categoryButton = new QToolButton;
           categoryButton->setToolButtonStyle(Qt::ToolButtonTextOnly);
           categoryButton->setText(category);
           categoryButton->setStyleSheet("background: transparent; margin: 0; padding: 0;");
           toolbar->addWidget(categoryButton);
 
           connect(categoryButton, &QToolButton::clicked, [toolbar]()
           {
             for (QWidget* widget : toolbar->findChildren<QWidget*>())
             {
               if (QStringLiteral("qt_toolbar_ext_button") == widget->objectName() && widget->isVisible())
               {
                 QMouseEvent pressEvent(QEvent::MouseButtonPress, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                 QMouseEvent releaseEvent(QEvent::MouseButtonRelease, QPointF(0.0f, 0.0f), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                 QApplication::sendEvent(widget, &pressEvent);
                 QApplication::sendEvent(widget, &releaseEvent);
               }
             }
           });
         }
 
         for (auto viewDescriptor : relevantViewDescriptors)
         {
           auto viewAction = new berry::QtShowViewAction(window, viewDescriptor);
           toolbar->addAction(viewAction);
         }
       }
     }
   }
 
   QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
   mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
 
   auto   qStatusBar = new QStatusBar();
 
   //creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
   auto  statusBar = new QmitkStatusBar(qStatusBar);
   //disabling the SizeGrip in the lower right corner
   statusBar->SetSizeGripEnabled(false);
 
   auto  progBar = new QmitkProgressBar();
 
   qStatusBar->addPermanentWidget(progBar, 0);
   progBar->hide();
 
   mainWindow->setStatusBar(qStatusBar);
 
   if (showMemoryIndicator)
   {
     auto   memoryIndicator = new QmitkMemoryUsageIndicatorView();
     qStatusBar->addPermanentWidget(memoryIndicator, 0);
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::PreWindowOpen()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
   this->HookTitleUpdateListeners(configurer);
 
   menuPerspectiveListener.reset(new PerspectiveListenerForMenu(this));
   configurer->GetWindow()->AddPerspectiveListener(menuPerspectiveListener.data());
 
   configurer->AddEditorAreaTransfer(QStringList("text/uri-list"));
   configurer->ConfigureEditorAreaDropListener(dropTargetListener.data());
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::PostWindowOpen()
 {
   berry::WorkbenchWindowAdvisor::PostWindowOpen();
   // Force Rendering Window Creation on startup.
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
 
   ctkPluginContext* context = QmitkFlowApplicationPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference serviceRef = context->getServiceReference<mitk::IDataStorageService>();
   if (serviceRef)
   {
     mitk::IDataStorageService *dsService = context->getService<mitk::IDataStorageService>(serviceRef);
     if (dsService)
     {
       mitk::IDataStorageReference::Pointer dsRef = dsService->GetDataStorage();
       mitk::DataStorageEditorInput::Pointer dsInput(new mitk::DataStorageEditorInput(dsRef));
       mitk::WorkbenchUtil::OpenEditor(configurer->GetWindow()->GetActivePage(),dsInput);
     }
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::onIntro()
 {
   QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack->onIntro();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::onHelp()
 {
   QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack->onHelp();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::onHelpOpenHelpPerspective()
 {
   QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack->onHelpOpenHelpPerspective();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::onAbout()
 {
   QmitkFlowApplicationWorkbenchWindowAdvisorHack::undohack->onAbout();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::HookTitleUpdateListeners(berry::IWorkbenchWindowConfigurer::Pointer configurer)
 {
   // hook up the listeners to update the window title
   titlePartListener.reset(new PartListenerForTitle(this));
   titlePerspectiveListener.reset(new PerspectiveListenerForTitle(this));
   editorPropertyListener.reset(new berry::PropertyChangeIntAdapter<
     QmitkFlowApplicationWorkbenchWindowAdvisor>(this,
     &QmitkFlowApplicationWorkbenchWindowAdvisor::PropertyChange));
 
   configurer->GetWindow()->AddPerspectiveListener(titlePerspectiveListener.data());
   configurer->GetWindow()->GetPartService()->AddPartListener(titlePartListener.data());
 }
 
 QString QmitkFlowApplicationWorkbenchWindowAdvisor::ComputeTitle()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   berry::IWorkbenchPage::Pointer currentPage = configurer->GetWindow()->GetActivePage();
   berry::IEditorPart::Pointer activeEditor;
   if (currentPage)
   {
     activeEditor = lastActiveEditor.Lock();
   }
 
   QString title;
   berry::IProduct::Pointer product = berry::Platform::GetProduct();
   if (product.IsNotNull())
   {
     title = product->GetName();
   }
   if (title.isEmpty())
   {
     // instead of the product name, we use a custom variable for now
     title = productName;
   }
 
   if(showMitkVersionInfo)
   {
     QString mitkVersionInfo = MITK_REVISION_DESC;
 
     if(mitkVersionInfo.isEmpty())
       mitkVersionInfo = MITK_VERSION_STRING;
 
     title += " " + mitkVersionInfo;
   }
 
   if (showVersionInfo)
   {
     // add version informatioin
     QString versions = QString(" (ITK %1.%2.%3 | VTK %4.%5.%6 | Qt %7)")
       .arg(ITK_VERSION_MAJOR).arg(ITK_VERSION_MINOR).arg(ITK_VERSION_PATCH)
       .arg(VTK_MAJOR_VERSION).arg(VTK_MINOR_VERSION).arg(VTK_BUILD_VERSION)
       .arg(QT_VERSION_STR);
 
     title += versions;
   }
 
   if (currentPage)
   {
     if (activeEditor)
     {
       lastEditorTitle = activeEditor->GetTitleToolTip();
       if (!lastEditorTitle.isEmpty())
         title = lastEditorTitle + " - " + title;
     }
     berry::IPerspectiveDescriptor::Pointer persp = currentPage->GetPerspective();
     QString label = "";
     if (persp)
     {
       label = persp->GetLabel();
     }
     berry::IAdaptable* input = currentPage->GetInput();
     if (input && input != wbAdvisor->GetDefaultPageInput())
     {
       label = currentPage->GetLabel();
     }
     if (!label.isEmpty())
     {
       title = label + " - " + title;
     }
   }
 
   title += " (Not for use in diagnosis or treatment of patients)";
 
   return title;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::RecomputeTitle()
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   QString oldTitle = configurer->GetTitle();
   QString newTitle = ComputeTitle();
   if (newTitle != oldTitle)
   {
     configurer->SetTitle(newTitle);
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::UpdateTitle(bool editorHidden)
 {
   berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
   berry::IWorkbenchWindow::Pointer window = configurer->GetWindow();
   berry::IEditorPart::Pointer activeEditor;
   berry::IWorkbenchPage::Pointer currentPage = window->GetActivePage();
   berry::IPerspectiveDescriptor::Pointer persp;
   berry::IAdaptable* input = nullptr;
 
   if (currentPage)
   {
     activeEditor = currentPage->GetActiveEditor();
     persp = currentPage->GetPerspective();
     input = currentPage->GetInput();
   }
 
   if (editorHidden)
   {
     activeEditor = nullptr;
   }
 
   // Nothing to do if the editor hasn't changed
   if (activeEditor == lastActiveEditor.Lock() && currentPage == lastActivePage.Lock()
     && persp == lastPerspective.Lock() && input == lastInput)
   {
     return;
   }
 
-  if (!lastActiveEditor.Expired())
+  auto lockedLastActiveEditor = lastActiveEditor.Lock();
+
+  if (lockedLastActiveEditor.IsNotNull())
   {
-    lastActiveEditor.Lock()->RemovePropertyListener(editorPropertyListener.data());
+    lockedLastActiveEditor->RemovePropertyListener(editorPropertyListener.data());
   }
 
   lastActiveEditor = activeEditor;
   lastActivePage = currentPage;
   lastPerspective = persp;
   lastInput = input;
 
   if (activeEditor)
   {
     activeEditor->AddPropertyListener(editorPropertyListener.data());
   }
 
   RecomputeTitle();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::PropertyChange(const berry::Object::Pointer& /*source*/, int propId)
 {
   if (propId == berry::IWorkbenchPartConstants::PROP_TITLE)
   {
-    if (!lastActiveEditor.Expired())
+    auto lockedLastActiveEditor = lastActiveEditor.Lock();
+
+    if (lockedLastActiveEditor.IsNotNull())
     {
-      QString newTitle = lastActiveEditor.Lock()->GetPartName();
+      QString newTitle = lockedLastActiveEditor->GetPartName();
       if (lastEditorTitle != newTitle)
       {
         RecomputeTitle();
       }
     }
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::SetPerspectiveExcludeList(const QList<QString>& v)
 {
   this->perspectiveExcludeList = v;
 }
 
 QList<QString> QmitkFlowApplicationWorkbenchWindowAdvisor::GetPerspectiveExcludeList()
 {
   return this->perspectiveExcludeList;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::SetViewExcludeList(const QList<QString>& v)
 {
   this->viewExcludeList = v;
 }
 
 QList<QString> QmitkFlowApplicationWorkbenchWindowAdvisor::GetViewExcludeList()
 {
   return this->viewExcludeList;
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisor::PostWindowClose()
 {
   berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
   QMainWindow* mainWindow = static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
   QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
   settings.setValue("ToolbarPosition", mainWindow->saveState());
 }
 
 QString QmitkFlowApplicationWorkbenchWindowAdvisor::GetQSettingsFile() const
 {
   QFileInfo settingsInfo = QmitkFlowApplicationPlugin::GetDefault()->GetPluginContext()->getDataFile(QT_SETTINGS_FILENAME);
   return settingsInfo.canonicalFilePath();
 }
 
 //--------------------------------------------------------------------------------
 // Ugly hack from here on. Feel free to delete when command framework
 // and undo buttons are done.
 //--------------------------------------------------------------------------------
 
 QmitkFlowApplicationWorkbenchWindowAdvisorHack::QmitkFlowApplicationWorkbenchWindowAdvisorHack()
   : QObject()
 {
 }
 
 QmitkFlowApplicationWorkbenchWindowAdvisorHack::~QmitkFlowApplicationWorkbenchWindowAdvisorHack()
 {
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onUndo()
 {
   mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
   if (model)
   {
     if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>(model))
     {
       mitk::VerboseLimitedLinearUndo::StackDescription descriptions = verboseundo->GetUndoDescriptions();
       if (descriptions.size() >= 1)
       {
         MITK_INFO << "Undo " << descriptions.front().second;
       }
     }
     model->Undo();
   }
   else
   {
     MITK_ERROR << "No undo model instantiated";
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onRedo()
 {
   mitk::UndoModel* model = mitk::UndoController::GetCurrentUndoModel();
   if (model)
   {
     if (mitk::VerboseLimitedLinearUndo* verboseundo = dynamic_cast<mitk::VerboseLimitedLinearUndo*>(model))
     {
       mitk::VerboseLimitedLinearUndo::StackDescription descriptions = verboseundo->GetRedoDescriptions();
       if (descriptions.size() >= 1)
       {
         MITK_INFO << "Redo " << descriptions.front().second;
       }
     }
     model->Redo();
   }
   else
   {
     MITK_ERROR << "No undo model instantiated";
   }
 }
 
 // safe calls to the complete chain
 // berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->FindView("org.mitk.views.imagenavigator");
 // to cover for all possible cases of closed pages etc.
 static void SafeHandleNavigatorView(QString view_query_name)
 {
   berry::IWorkbench* wbench = berry::PlatformUI::GetWorkbench();
   if (wbench == nullptr)
     return;
 
   berry::IWorkbenchWindow::Pointer wbench_window = wbench->GetActiveWorkbenchWindow();
   if (wbench_window.IsNull())
     return;
 
   berry::IWorkbenchPage::Pointer wbench_page = wbench_window->GetActivePage();
   if (wbench_page.IsNull())
     return;
 
   auto wbench_view = wbench_page->FindView(view_query_name);
 
   if (wbench_view.IsNotNull())
   {
     bool isViewVisible = wbench_page->IsPartVisible(wbench_view);
     if (isViewVisible)
     {
       wbench_page->HideView(wbench_view);
       return;
     }
 
   }
 
   wbench_page->ShowView(view_query_name);
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onImageNavigator()
 {
   // show/hide ImageNavigatorView
   SafeHandleNavigatorView("org.mitk.views.imagenavigator");
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onEditPreferences()
 {
   QmitkPreferencesDialog _PreferencesDialog(QApplication::activeWindow());
   _PreferencesDialog.exec();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onQuit()
 {
   berry::PlatformUI::GetWorkbench()->Close();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onResetPerspective()
 {
   berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onClosePerspective()
 {
   berry::IWorkbenchPage::Pointer page =
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage();
   page->ClosePerspective(page->GetPerspective(), true, true);
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onIntro()
 {
   bool hasIntro =
     berry::PlatformUI::GetWorkbench()->GetIntroManager()->HasIntro();
   if (!hasIntro)
   {
     QRegExp reg("(.*)<title>(\\n)*");
     QRegExp reg2("(\\n)*</title>(.*)");
     QFile file(":/org.mitk.gui.qt.ext/index.html");
     file.open(QIODevice::ReadOnly | QIODevice::Text); //text file only for reading
 
     QString text = QString(file.readAll());
 
     file.close();
 
     QString title = text;
     title.replace(reg, "");
     title.replace(reg2, "");
 
     std::cout << title.toStdString() << std::endl;
 
     QMessageBox::information(nullptr, title,
       text, "Close");
   }
   else
   {
     berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
       berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow(), false);
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onHelp()
 {
   ctkPluginContext* context = QmitkFlowApplicationPlugin::GetDefault()->GetPluginContext();
   if (context == nullptr)
   {
     MITK_WARN << "Plugin context not set, unable to open context help";
     return;
   }
 
   // Check if the org.blueberry.ui.qt.help plug-in is installed and started
   QList<QSharedPointer<ctkPlugin> > plugins = context->getPlugins();
   foreach(QSharedPointer<ctkPlugin> p, plugins)
   {
     if (p->getSymbolicName() == "org.blueberry.ui.qt.help")
     {
       if (p->getState() != ctkPlugin::ACTIVE)
       {
         // try to activate the plug-in explicitly
         try
         {
           p->start(ctkPlugin::START_TRANSIENT);
         }
         catch (const ctkPluginException& pe)
         {
           MITK_ERROR << "Activating org.blueberry.ui.qt.help failed: " << pe.what();
           return;
         }
       }
     }
   }
 
   ctkServiceReference eventAdminRef = context->getServiceReference<ctkEventAdmin>();
   ctkEventAdmin* eventAdmin = nullptr;
   if (eventAdminRef)
   {
     eventAdmin = context->getService<ctkEventAdmin>(eventAdminRef);
   }
   if (eventAdmin == nullptr)
   {
     MITK_WARN << "ctkEventAdmin service not found. Unable to open context help";
   }
   else
   {
     ctkEvent ev("org/blueberry/ui/help/CONTEXTHELP_REQUESTED");
     eventAdmin->postEvent(ev);
   }
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onHelpOpenHelpPerspective()
 {
   berry::PlatformUI::GetWorkbench()->ShowPerspective("org.blueberry.perspectives.help",
     berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow());
 }
 
 void QmitkFlowApplicationWorkbenchWindowAdvisorHack::onAbout()
 {
   auto aboutDialog = new QmitkAboutDialog(QApplication::activeWindow(), nullptr);
   aboutDialog->open();
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/manifest_headers.cmake
index e4fbb21aac..473ac96eb1 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "IGT APP: Hummel Protocol Measurements")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
 set(Plugin-ContactAddress "http://www.mitk.org")
-set(Require-Plugin org.mitk.gui.qt.common.legacy)
+set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.cpp b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.cpp
index 37a99df5ab..7ca288ff21 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.cpp
@@ -1,1164 +1,1152 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #include <algorithm>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkIGTTrackingDataEvaluationView.h"
 
 // Qt
 #include <QMessageBox>
 #include <qfiledialog.h>
 #include <qstringlist.h>
 
 // MITK
 #include "mitkNavigationDataCSVSequentialPlayer.h"
 #include <mitkNavigationDataRecorderDeprecated.h>
 #include <mitkQuaternionAveraging.h>
 #include <mitkTransform.h>
 #include <mitkStaticIGTHelperFunctions.h>
 #include <mitkNodePredicateDataType.h>
 
 
 //ITK
 #include <itksys/SystemTools.hxx>
 
 //VNL
 #include <vnl/vnl_vector.h>
 
 //vtk headers
 #include <vtkPoints.h>
 #include <vtkSmartPointer.h>
 #include <vtkLandmarkTransform.h>
 
 const std::string QmitkIGTTrackingDataEvaluationView::VIEW_ID = "org.mitk.views.igttrackingdataevaluation";
 
 QmitkIGTTrackingDataEvaluationView::QmitkIGTTrackingDataEvaluationView()
-  : QmitkFunctionality()
-  , m_Controls(nullptr)
-  , m_MultiWidget(nullptr)
+  : m_Controls(nullptr)
   , m_scalingfactor(1)
 {
   m_CSVtoXMLInputFilenameVector = std::vector<std::string>();
   m_CSVtoXMLOutputFilenameVector = std::vector<std::string>();
 }
 
 QmitkIGTTrackingDataEvaluationView::~QmitkIGTTrackingDataEvaluationView()
 {
 }
 
 void QmitkIGTTrackingDataEvaluationView::CreateQtPartControl(QWidget *parent)
 {
   // build up qt view, unless already done
   if (!m_Controls)
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkIGTTrackingDataEvaluationViewControls;
     m_Controls->setupUi(parent);
 
     connect(m_Controls->m_LoadInputFileList, SIGNAL(clicked()), this, SLOT(OnLoadFileList()));
     connect(m_Controls->m_StartEvaluation, SIGNAL(clicked()), this, SLOT(OnEvaluateData()));
     connect(m_Controls->m_AddToCurrentList, SIGNAL(clicked()), this, SLOT(OnAddToCurrentList()));
     connect(m_Controls->m_GeneratePointSetOfMeanPositions, SIGNAL(clicked()), this, SLOT(OnGeneratePointSet()));
     connect(m_Controls->m_GenerateRotationLines, SIGNAL(clicked()), this, SLOT(OnGenerateRotationLines()));
     connect(m_Controls->m_GeneratePointSet, SIGNAL(clicked()), this, SLOT(OnGenerateGroundTruthPointSet()));
     connect(m_Controls->m_Convert, SIGNAL(clicked()), this, SLOT(OnConvertCSVtoXMLFile()));
     connect(m_Controls->m_loadCSVtoXMLInputList, SIGNAL(clicked()), this, SLOT(OnCSVtoXMLLoadInputList()));
     connect(m_Controls->m_loadCSVtoXMLOutputList, SIGNAL(clicked()), this, SLOT(OnCSVtoXMLLoadOutputList()));
     connect(m_Controls->m_OrientationCalculationGenerateReference, SIGNAL(clicked()), this, SLOT(OnOrientationCalculation_CalcRef()));
     connect(m_Controls->m_OrientationCalculationWriteOrientationsToFile, SIGNAL(clicked()), this, SLOT(OnOrientationCalculation_CalcOrientandWriteToFile()));
     connect(m_Controls->m_GeneratePointSetsOfSinglePositions, SIGNAL(clicked()), this, SLOT(OnGeneratePointSetsOfSinglePositions()));
     connect(m_Controls->m_StartEvaluationAll, SIGNAL(clicked()), this, SLOT(OnEvaluateDataAll()));
     connect(m_Controls->m_GridMatching, SIGNAL(clicked()), this, SLOT(OnPerfomGridMatching()));
     connect(m_Controls->m_ComputeRotation, SIGNAL(clicked()), this, SLOT(OnComputeRotation()));
 
     //initialize data storage combo boxes
     m_Controls->m_ReferencePointSetComboBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ReferencePointSetComboBox->SetAutoSelectNewItems(true);
     m_Controls->m_ReferencePointSetComboBox->SetPredicate(mitk::NodePredicateDataType::New("PointSet"));
     m_Controls->m_MeasurementPointSetComboBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_MeasurementPointSetComboBox->SetAutoSelectNewItems(true);
     m_Controls->m_MeasurementPointSetComboBox->SetPredicate(mitk::NodePredicateDataType::New("PointSet"));
   }
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnComputeRotation()
 {
   //Get all data from UI
   auto EvaluationDataCollection = GetAllDataFromUIList();
   //Compute mean Quaternions
   auto OrientationVector = GetMeanOrientationsOfAllData(EvaluationDataCollection);
 
   //Compute Rotations
 
   itk::Vector<double> rotationVec;
   //adapt for Aurora 5D tools: [0,0,1000]
   rotationVec[0] = m_Controls->m_rotVecX->value(); //X
   rotationVec[1] = m_Controls->m_rotVecY->value(); //Y
   rotationVec[2] = m_Controls->m_rotVecZ->value(); //Z
 
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> allOrientationErrors;
   for (std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError>::size_type i = 0; i < OrientationVector.size() - 1; ++i)
   {
     double AngleBetweenTwoQuaternions = mitk::StaticIGTHelperFunctions::GetAngleBetweenTwoQuaterions(OrientationVector.at(i), OrientationVector.at(i+1), rotationVec);
     double AngularError = fabs(AngleBetweenTwoQuaternions - 11.25);
     std::stringstream description;
     description << "Rotation Error ROT" << (i + 1) << " / ROT" << (i + 2);
     allOrientationErrors.push_back({ AngularError, description.str() });
     MITK_INFO << description.str() << ": " << AngularError;
   }
 
   //compute statistics
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> orientationErrorStatistics;
   orientationErrorStatistics = mitk::HummelProtocolEvaluation::ComputeStatistics(allOrientationErrors);
   MITK_INFO << "## Rotation error statistics: ##";
   for (auto stat : orientationErrorStatistics) { MITK_INFO << stat.description << ": " << stat.distanceError; }
 
   //write results to file
   allOrientationErrors.insert(allOrientationErrors.end(), orientationErrorStatistics.begin(), orientationErrorStatistics.end());
   allOrientationErrors.push_back({rotationVec[0],"Rot Vector [x]"});
   allOrientationErrors.push_back({rotationVec[1], "Rot Vector [y]"});
   allOrientationErrors.push_back({rotationVec[2], "Rot Vector [z]"});
   std::stringstream filenameOrientationStat;
   filenameOrientationStat << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".orientationStatistics.csv";
   MITK_INFO << "Writing output to file " << filenameOrientationStat.str();
   writeToFile(filenameOrientationStat.str(), allOrientationErrors);
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnPerfomGridMatching()
 {
   mitk::PointSet::Pointer reference = dynamic_cast<mitk::PointSet*>(m_Controls->m_ReferencePointSetComboBox->GetSelectedNode()->GetData());
   mitk::PointSet::Pointer measurement = dynamic_cast<mitk::PointSet*>(m_Controls->m_MeasurementPointSetComboBox->GetSelectedNode()->GetData());
   //convert point sets to vtk poly data
   vtkSmartPointer<vtkPoints> sourcePoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPoints> targetPoints = vtkSmartPointer<vtkPoints>::New();
   for (int i = 0; i<reference->GetSize(); i++)
   {
     double point[3] = { reference->GetPoint(i)[0], reference->GetPoint(i)[1], reference->GetPoint(i)[2] };
     sourcePoints->InsertNextPoint(point);
     double point_targets[3] = { measurement->GetPoint(i)[0], measurement->GetPoint(i)[1], measurement->GetPoint(i)[2] };
     targetPoints->InsertNextPoint(point_targets);
   }
   //compute transform
   vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
   transform->SetSourceLandmarks(sourcePoints);
   transform->SetTargetLandmarks(targetPoints);
   transform->SetModeToRigidBody();
   transform->Modified();
   transform->Update();
   //compute FRE of transform
   double FRE = mitk::StaticIGTHelperFunctions::ComputeFRE(reference, measurement, transform);
   MITK_INFO << "FRE after grid matching: " + QString::number(FRE) + " mm";
   //convert from vtk to itk data types
   itk::Matrix<float, 3, 3> rotationFloat = itk::Matrix<float, 3, 3>();
   itk::Vector<float, 3> translationFloat = itk::Vector<float, 3>();
   itk::Matrix<double, 3, 3> rotationDouble = itk::Matrix<double, 3, 3>();
   itk::Vector<double, 3> translationDouble = itk::Vector<double, 3>();
 
   vtkSmartPointer<vtkMatrix4x4> m = transform->GetMatrix();
   for (int k = 0; k<3; k++) for (int l = 0; l<3; l++)
   {
     rotationFloat[k][l] = m->GetElement(k, l);
     rotationDouble[k][l] = m->GetElement(k, l);
 
   }
   for (int k = 0; k<3; k++)
   {
     translationFloat[k] = m->GetElement(k, 3);
     translationDouble[k] = m->GetElement(k, 3);
   }
   //create affine transform 3D
   mitk::AffineTransform3D::Pointer mitkTransform = mitk::AffineTransform3D::New();
   mitkTransform->SetMatrix(rotationDouble);
   mitkTransform->SetOffset(translationDouble);
   mitk::NavigationData::Pointer transformNavigationData = mitk::NavigationData::New(mitkTransform);
   m_Controls->m_ReferencePointSetComboBox->GetSelectedNode()->GetData()->GetGeometry()->SetIndexToWorldTransform(mitkTransform);
   m_Controls->m_ReferencePointSetComboBox->GetSelectedNode()->GetData()->GetGeometry()->Modified();
 
   //write to file
 
   std::stringstream filename;
   filename << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".GridMatchingResult.csv";
   MITK_INFO << "Writing output to file " << filename.str();
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> FRE_Error;
   FRE_Error.push_back({ FRE, "FRE after grid matching [mm]" });
   writeToFile(filename.str(), FRE_Error);
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnOrientationCalculation_CalcRef()
 {
   if (m_FilenameVector.size() != 3)
   {
     MessageBox("Need exactly three points as reference, aborting!");
     return;
   }
 
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector[i]);
 
     //check if the stream is valid and skip file if not
 
     //create evaluation filter
     mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 
     //connect pipeline
     for (unsigned int j = 0; j < myPlayer->GetNumberOfOutputs(); ++j)
       myEvaluationFilter->SetInput(j, myPlayer->GetOutput(j));
 
     //update pipline until number of samples is reached
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); ++j)
       myEvaluationFilter->Update();
 
     //store mean position as reference
     switch (i)
     {
     case 0:
       m_RefPoint1 = myEvaluationFilter->GetPositionMean(0);
       break;
     case 1:
       m_RefPoint2 = myEvaluationFilter->GetPositionMean(0);
       break;
     case 2:
       m_RefPoint3 = myEvaluationFilter->GetPositionMean(0);
       break;
     }
   }
   MessageBox("Created Reference!");
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnOrientationCalculation_CalcOrientandWriteToFile()
 {
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //open file header
     QString outputname = QString(m_FilenameVector.at(i).c_str()) + "_orientationFile.csv";
     m_CurrentWriteFile.open(outputname.toStdString().c_str(), std::ios::out);
     if (m_CurrentWriteFile.bad())
     {
       MessageBox("Error: Can't open output file!");
       return;
     }
 
     //write header to file
     m_CurrentWriteFile << "Nr;Calypso_Time;Valid_Reference;MeasureTool_Measurement-Tool[x];MeasureTool_Measurement-Tool[y];MeasureTool_Measurement-Tool[z];MeasureTool_Measurement-Tool[qx];MeasureTool_Measurement-Tool[qy];MeasureTool_Measurement-Tool[qz];MeasureTool_Measurement-Tool[qr]\n";
 
     //update pipeline until number of samples is reached
     int step = 0;
     mitk::Point3D point1, point2, point3;
     mitk::Quaternion current_orientation;
 
     for (int j = 0; !myPlayer->IsAtEnd(); j++)
     {
       myPlayer->Update();
       mitk::NavigationData::Pointer currentNavData = myPlayer->GetOutput(0);
       switch (step)
       {
       case 0:
         step++;
         point1 = currentNavData->GetPosition();
         break;
       case 1:
         step++;
         point2 = currentNavData->GetPosition();
         break;
       case 2:
         step = 0;
         point3 = currentNavData->GetPosition();
 
         //compute transform from reference to current points
         if (point1[0] == 0 &&
           point1[1] == 0 &&
           point1[2] == 0 &&
           point2[0] == 0 &&
           point2[1] == 0 &&
           point2[2] == 0 &&
           point3[0] == 0 &&
           point3[1] == 0 &&
           point3[2] == 0
           ) current_orientation.fill(0);
         else
         {
           vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
           vtkSmartPointer<vtkPoints> sourcePoints = vtkSmartPointer<vtkPoints>::New();
           double sourcepoint1[3] = { point1[0], point1[1], point1[2] };
           double sourcepoint2[3] = { point2[0], point2[1], point2[2] };
           double sourcepoint3[3] = { point3[0], point3[1], point3[2] };
           sourcePoints->InsertNextPoint(sourcepoint1);
           sourcePoints->InsertNextPoint(sourcepoint2);
           sourcePoints->InsertNextPoint(sourcepoint3);
           vtkSmartPointer<vtkPoints> targetPoints = vtkSmartPointer<vtkPoints>::New();
           double targetpoint1[3] = { m_RefPoint1[0], m_RefPoint1[1], m_RefPoint1[2] };
           double targetpoint2[3] = { m_RefPoint2[0], m_RefPoint2[1], m_RefPoint2[2] };
           double targetpoint3[3] = { m_RefPoint3[0], m_RefPoint3[1], m_RefPoint3[2] };
           targetPoints->InsertNextPoint(targetpoint1);
           targetPoints->InsertNextPoint(targetpoint2);
           targetPoints->InsertNextPoint(targetpoint3);
 
           transform->SetSourceLandmarks(sourcePoints);
           transform->SetTargetLandmarks(targetPoints);
           transform->Modified();
           transform->Update();
 
           mitk::Transform::Pointer newTransform = mitk::Transform::New();
           newTransform->SetMatrix(transform->GetMatrix());
           current_orientation = newTransform->GetOrientation();
 
           //add pointset with the three positions
           if ((j > 15) && (j < 18))
           {
             mitk::DataNode::Pointer newNode = mitk::DataNode::New();
             mitk::PointSet::Pointer newPointSet = mitk::PointSet::New();
             newPointSet->InsertPoint(0, point1);
             newPointSet->InsertPoint(1, point2);
             newPointSet->InsertPoint(2, point3);
             QString name = QString(m_FilenameVector.at(i).c_str());
             newNode->SetName(name.toStdString().c_str());
             newNode->SetData(newPointSet);
             newNode->SetFloatProperty("pointsize", 0.1);
             this->GetDataStorage()->Add(newNode);
           }
         }
 
         break;
       }
       m_CurrentWriteFile << i << ";";
       m_CurrentWriteFile << currentNavData->GetTimeStamp() << ";"; //IMPORTANT: change to GetIGTTimeStamp in new version!
       m_CurrentWriteFile << "true;";
       m_CurrentWriteFile << currentNavData->GetPosition()[0] << ";";
       m_CurrentWriteFile << currentNavData->GetPosition()[1] << ";";
       m_CurrentWriteFile << currentNavData->GetPosition()[2] << ";";
       m_CurrentWriteFile << current_orientation.x() << ";";
       m_CurrentWriteFile << current_orientation.y() << ";";
       m_CurrentWriteFile << current_orientation.z() << ";";
       m_CurrentWriteFile << current_orientation.r() << ";";
       m_CurrentWriteFile << "\n";
     }
     //close output file
     m_CurrentWriteFile.close();
   }
   MessageBox("Finished!");
 }
 
-void QmitkIGTTrackingDataEvaluationView::MultiWidgetAvailable(QmitkAbstractMultiWidget &multiWidget)
-{
-  m_MultiWidget = dynamic_cast<QmitkStdMultiWidget*>(&multiWidget);
-}
-
-void QmitkIGTTrackingDataEvaluationView::MultiWidgetNotAvailable()
-{
-  m_MultiWidget = nullptr;
-}
-
 void QmitkIGTTrackingDataEvaluationView::OnAddToCurrentList()
 {
   //read in files
   QStringList files = QFileDialog::getOpenFileNames(nullptr, "Select one or more files to open", "/", "CSV (*.csv)");
   if (files.isEmpty()) return;
 
   for (int i = 0; i < files.size(); i++)
   {
     std::string tmp = files.at(i).toStdString().c_str();
     m_FilenameVector.push_back(tmp);
   }
 
   //fill list at GUI
   m_Controls->m_FileList->clear();
   for (unsigned int i = 0; i < m_FilenameVector.size(); i++) { new QListWidgetItem(tr(m_FilenameVector.at(i).c_str()), m_Controls->m_FileList); }
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnLoadFileList()
 {
   m_FilenameVector = std::vector<std::string>();
   m_FilenameVector.clear();
   OnAddToCurrentList();
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnEvaluateDataAll()
 {
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> results5cm, results15cm, results30cm, resultsAccum;
   mitk::HummelProtocolEvaluation::HummelProtocolMeasurementVolume volume;
   if (m_Controls->m_standardVolume->isChecked())
   {
     volume = mitk::HummelProtocolEvaluation::standard;
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_PointSetMeanPositions, volume, results5cm);
     mitk::HummelProtocolEvaluation::Evaluate15cmDistances(m_PointSetMeanPositions, volume, results15cm);
     mitk::HummelProtocolEvaluation::Evaluate30cmDistances(m_PointSetMeanPositions, volume, results30cm);
     mitk::HummelProtocolEvaluation::EvaluateAccumulatedDistances(m_PointSetMeanPositions, volume, resultsAccum);
   }
   else if (m_Controls->m_smallVolume->isChecked())
   {
     volume = mitk::HummelProtocolEvaluation::small;
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_PointSetMeanPositions, volume, results5cm);
   }
   else if (m_Controls->m_mediumVolume->isChecked())
   {
     volume = mitk::HummelProtocolEvaluation::medium;
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_PointSetMeanPositions, volume, results5cm);
   }
 
 
   //write results to file
   std::stringstream filename5cm;
   filename5cm << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".results5cm.csv";
   MITK_INFO << "Writing output to file " << filename5cm.str();
   writeToFile(filename5cm.str(), results5cm);
 
   std::stringstream filename15cm;
   filename15cm << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".results15cm.csv";
   MITK_INFO << "Writing output to file " << filename15cm.str();
   writeToFile(filename15cm.str(), results15cm);
 
   std::stringstream filename30cm;
   filename30cm << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".results30cm.csv";
   MITK_INFO << "Writing output to file " << filename30cm.str();
   writeToFile(filename30cm.str(), results30cm);
 
   std::stringstream filenameAccum;
   filenameAccum << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".resultsAccumDist.csv";
   MITK_INFO << "Writing output to file " << filenameAccum.str();
   writeToFile(filenameAccum.str(), resultsAccum);
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnEvaluateData()
 {
   //open output file
   m_CurrentWriteFile.open(std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str(), std::ios::out);
   if (m_CurrentWriteFile.bad())
   {
     MessageBox("Error: Can't open output file!");
     return;
   }
 
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> jitterValues;
 
   //write output file header
   WriteHeader();
 
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //create evaluation filter
     mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 
     //connect pipeline
     for (unsigned int j = 0; j < myPlayer->GetNumberOfOutputs(); ++i) { myEvaluationFilter->SetInput(j, myPlayer->GetOutput(j)); }
 
     if (myPlayer->GetNumberOfSnapshots() < m_Controls->m_NumberOfSamples->value())
     {
       MITK_WARN << "Number of snapshots (" << myPlayer->GetNumberOfSnapshots() << ") smaller than number of samples to evaluate (" << m_Controls->m_NumberOfSamples->value() << ") ! Cannot proceed!";
       return;
     }
 
     //update pipline until number of samples is reached
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); j++)
       myEvaluationFilter->Update();
 
     //store all jitter values in separate vector for statistics
     jitterValues.push_back({ myEvaluationFilter->GetPositionErrorRMS(0), "RMS" });
 
     //write result to output file
     WriteDataSet(myEvaluationFilter, m_FilenameVector.at(i));
   }
 
   //close output file for single data
   m_CurrentWriteFile.close();
 
   //compute statistics
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> jitterStatistics = mitk::HummelProtocolEvaluation::ComputeStatistics(jitterValues);
   MITK_INFO << "## Jitter (RMS) statistics: ##";
   for (auto jitterStat : jitterStatistics) {MITK_INFO << jitterStat.description << ": " << jitterStat.distanceError;}
 
   //write statistic results to separate file
   std::stringstream filenameJitterStat;
   filenameJitterStat << std::string(m_Controls->m_OutputFilename->text().toUtf8()).c_str() << ".resultsJitterStatistics.csv";
   MITK_INFO << "Writing output to file " << filenameJitterStat.str();
   writeToFile(filenameJitterStat.str(), jitterStatistics);
 
   //calculate angles if option is on
   if (m_Controls->m_settingDifferenceAngles->isChecked() || m_Controls->m_DifferencesSLERP->isChecked()) CalculateDifferenceAngles();
 
   MessageBox("Finished!");
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnGeneratePointSetsOfSinglePositions()
 {
   m_scalingfactor = m_Controls->m_ScalingFactor->value();
 
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create point set for this file
     mitk::PointSet::Pointer thisPointSet = mitk::PointSet::New();
 
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //update pipline until number of samlples is reached and store every single point
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); j++)
     {
       myPlayer->Update();
       mitk::Point3D thisPoint = myPlayer->GetOutput()->GetPosition();
       thisPoint[0] *= m_scalingfactor;
       thisPoint[1] *= m_scalingfactor;
       thisPoint[2] *= m_scalingfactor;
       thisPointSet->InsertPoint(j, thisPoint);
     }
 
     //add point set to data storage
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     QString name = this->m_Controls->m_prefix->text() + QString("PointSet_of_All_Positions_") + QString::number(i);
     newNode->SetName(name.toStdString());
     newNode->SetData(thisPointSet);
     this->GetDataStorage()->Add(newNode);
   }
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnGeneratePointSet()
 {
   m_scalingfactor = m_Controls->m_ScalingFactor->value();
 
   mitk::PointSet::Pointer generatedPointSet = mitk::PointSet::New();
 
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //create evaluation filter
     mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 
     //connect pipeline
     for (unsigned int j = 0; j < myPlayer->GetNumberOfOutputs(); ++j) { myEvaluationFilter->SetInput(j, myPlayer->GetOutput(j)); }
 
     //update pipline until number of samlples is reached
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); ++j) { myEvaluationFilter->Update(); }
 
     //add mean position to point set
     mitk::Point3D meanPos = myEvaluationFilter->GetPositionMean(0);
     if (m_scalingfactor != 1)
     {
       meanPos[0] *= m_scalingfactor;
       meanPos[1] *= m_scalingfactor;
       meanPos[2] *= m_scalingfactor;
     }
     generatedPointSet->InsertPoint(i, meanPos);
   }
 
   //add point set to data storage
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   QString name = this->m_Controls->m_prefix->text() + "PointSet_of_Mean_Positions";
   newNode->SetName(name.toStdString());
   newNode->SetData(generatedPointSet);
   newNode->SetFloatProperty("pointsize", 5);
   this->GetDataStorage()->Add(newNode);
   m_PointSetMeanPositions = generatedPointSet;
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnGenerateRotationLines()
 {
   m_scalingfactor = m_Controls->m_ScalingFactor->value();
 
   //start loop and iterate through all files of list
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //create evaluation filter
     mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 
     //connect pipeline
     for (unsigned int j = 0; j < myPlayer->GetNumberOfOutputs(); ++j) { myEvaluationFilter->SetInput(j, myPlayer->GetOutput(j)); }
 
     //update pipline until number of samlples is reached
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); ++j)
       myEvaluationFilter->Update();
 
     //create line from mean pos to a second point which lies along the sensor (1,0,0 in tool coordinates for aurora)
     mitk::Point3D meanPos = myEvaluationFilter->GetPositionMean(0);
     if (m_scalingfactor != 1)
     {
       meanPos[0] *= m_scalingfactor;
       meanPos[1] *= m_scalingfactor;
       meanPos[2] *= m_scalingfactor;
     }
     mitk::Point3D secondPoint;
     mitk::Point3D thirdPoint;
     mitk::Point3D fourthPoint;
 
     mitk::FillVector3D(secondPoint, 2, 0, 0); //X
     vnl_vector<mitk::ScalarType> secondPointTransformed = myEvaluationFilter->GetQuaternionMean(0).rotation_matrix_transpose().transpose() * secondPoint.GetVnlVector() + meanPos.GetVnlVector();
     mitk::Point3D secondPointTransformedMITK;
     mitk::FillVector3D(secondPointTransformedMITK, secondPointTransformed[0], secondPointTransformed[1], secondPointTransformed[2]);
 
     mitk::FillVector3D(thirdPoint, 0, 4, 0); //Y
     vnl_vector<mitk::ScalarType> thirdPointTransformed = myEvaluationFilter->GetQuaternionMean(0).rotation_matrix_transpose().transpose() * thirdPoint.GetVnlVector() + meanPos.GetVnlVector();
     mitk::Point3D thirdPointTransformedMITK;
     mitk::FillVector3D(thirdPointTransformedMITK, thirdPointTransformed[0], thirdPointTransformed[1], thirdPointTransformed[2]);
 
     mitk::FillVector3D(fourthPoint, 0, 0, 6); //Z
     vnl_vector<mitk::ScalarType> fourthPointTransformed = myEvaluationFilter->GetQuaternionMean(0).rotation_matrix_transpose().transpose() * fourthPoint.GetVnlVector() + meanPos.GetVnlVector();
     mitk::Point3D fourthPointTransformedMITK;
     mitk::FillVector3D(fourthPointTransformedMITK, fourthPointTransformed[0], fourthPointTransformed[1], fourthPointTransformed[2]);
 
     mitk::PointSet::Pointer rotationLine = mitk::PointSet::New();
     rotationLine->InsertPoint(0, secondPointTransformedMITK);
     rotationLine->InsertPoint(1, meanPos);
     rotationLine->InsertPoint(2, thirdPointTransformedMITK);
     rotationLine->InsertPoint(3, meanPos);
     rotationLine->InsertPoint(4, fourthPointTransformedMITK);
 
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     QString nodeName = this->m_Controls->m_prefix->text() + "RotationLineNumber" + QString::number(i);
     newNode->SetName(nodeName.toStdString());
     newNode->SetData(rotationLine);
     newNode->SetBoolProperty("show contour", true);
     newNode->SetFloatProperty("pointsize", 0.5);
     this->GetDataStorage()->Add(newNode);
   }
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnGenerateGroundTruthPointSet()
 {
   mitk::PointSet::Pointer generatedPointSet = mitk::PointSet::New();
   int currentPointID = 0;
   mitk::Point3D currentPoint;
   mitk::FillVector3D(currentPoint, 0, 0, 0);
   for (int i = 0; i < m_Controls->m_PointNumber2->value(); i++)
   {
     for (int j = 0; j < m_Controls->m_PointNumber1->value(); j++)
     {
       generatedPointSet->InsertPoint(currentPointID, currentPoint);
       currentPointID++;
       currentPoint[1] += m_Controls->m_PointDistance->value();
     }
     currentPoint[1] = 0;
     currentPoint[2] += m_Controls->m_PointDistance->value();
   }
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   QString nodeName = "GroundTruthPointSet_" + QString::number(m_Controls->m_PointNumber1->value()) + "x" + QString::number(m_Controls->m_PointNumber2->value()) + "_(" + QString::number(m_Controls->m_PointDistance->value()) + "mm)";
   newNode->SetName(nodeName.toStdString());
   newNode->SetData(generatedPointSet);
   newNode->SetFloatProperty("pointsize", 5);
   this->GetDataStorage()->Add(newNode);
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnConvertCSVtoXMLFile()
 {
   if (m_Controls->m_ConvertSingleFile->isChecked())
   { //convert one file
     int lines = ConvertOneFile(this->m_Controls->m_InputCSV->text().toStdString(), this->m_Controls->m_OutputXML->text().toStdString());
 
     QString result = "Converted one file with" + QString::number(lines) + " data sets";
     MessageBox(result.toStdString());
   }
   else //converte file list
   {
     if (m_CSVtoXMLInputFilenameVector.empty() || m_CSVtoXMLOutputFilenameVector.empty())
     {
       MessageBox("Error: one list is not loaded!");
       return;
     }
     else if (m_CSVtoXMLInputFilenameVector.size() != m_CSVtoXMLOutputFilenameVector.size())
     {
       MessageBox("Error: lists do not have the same number of files!");
       return;
     }
     for (std::size_t i = 0; i < m_CSVtoXMLInputFilenameVector.size(); ++i)
     {
       ConvertOneFile(m_CSVtoXMLInputFilenameVector.at(i), m_CSVtoXMLOutputFilenameVector.at(i));
     }
     QString result = "Converted " + QString::number(m_CSVtoXMLInputFilenameVector.size()) + " files from file list!";
     MessageBox(result.toStdString());
   }
 }
 
 int QmitkIGTTrackingDataEvaluationView::ConvertOneFile(std::string inputFilename, std::string outputFilename)
 {
   std::vector<mitk::NavigationData::Pointer> myNavigationDatas = GetNavigationDatasFromFile(inputFilename);
   mitk::NavigationDataRecorderDeprecated::Pointer myRecorder = mitk::NavigationDataRecorderDeprecated::New();
   myRecorder->SetFileName(outputFilename.c_str());
   mitk::NavigationData::Pointer input = mitk::NavigationData::New();
   if (m_Controls->m_ConvertCSV->isChecked()) myRecorder->SetOutputFormat(mitk::NavigationDataRecorderDeprecated::csv);
   myRecorder->AddNavigationData(input);
   myRecorder->StartRecording();
   for (std::size_t i = 0; i < myNavigationDatas.size(); ++i)
   {
     input->Graft(myNavigationDatas.at(i));
     myRecorder->Update();
   }
   myRecorder->StopRecording();
   return myNavigationDatas.size();
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnCSVtoXMLLoadInputList()
 {
   //read in filename
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Measurement Filename List"), "/", tr("All Files (*.*)"));
   if (filename.isNull()) return;
 
   m_CSVtoXMLInputFilenameVector = this->GetFileContentLineByLine(filename.toStdString());
 
   m_Controls->m_labelCSVtoXMLInputList->setText("READY");
 }
 
 void QmitkIGTTrackingDataEvaluationView::OnCSVtoXMLLoadOutputList()
 {
   //read in filename
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Measurement Filename List"), "/", tr("All Files (*.*)"));
   if (filename.isNull()) return;
 
   m_CSVtoXMLOutputFilenameVector = this->GetFileContentLineByLine(filename.toStdString());
 
   m_Controls->m_labelCSVtoXMLOutputList->setText("READY");
 }
 
 void QmitkIGTTrackingDataEvaluationView::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkIGTTrackingDataEvaluationView::WriteHeader()
 {
   m_CurrentWriteFile << "Filename;";
   m_CurrentWriteFile << "N;";
   m_CurrentWriteFile << "N_invalid;";
   m_CurrentWriteFile << "Percentage_invalid;";
 
   if (m_Controls->m_settingPosMean->isChecked())
   {
     m_CurrentWriteFile << "Position_Mean[x];";
     m_CurrentWriteFile << "Position_Mean[y];";
     m_CurrentWriteFile << "Position_Mean[z];";
   }
 
   if (m_Controls->m_settingPosStabw->isChecked())
   {
     m_CurrentWriteFile << "Position_StandDev[x];";
     m_CurrentWriteFile << "Position_StandDev[y];";
     m_CurrentWriteFile << "Position_StandDev[z];";
   }
 
   if (m_Controls->m_settingPosSampleStabw->isChecked())
   {
     m_CurrentWriteFile << "Position_SampleStandDev[x];";
     m_CurrentWriteFile << "Position_SampleStandDev[y];";
     m_CurrentWriteFile << "Position_SampleStandDev[z];";
   }
 
   if (m_Controls->m_settingQuaternionMean->isChecked())
   {
     m_CurrentWriteFile << "Quaternion_Mean[qx];";
     m_CurrentWriteFile << "Quaternion_Mean[qy];";
     m_CurrentWriteFile << "Quaternion_Mean[qz];";
     m_CurrentWriteFile << "Quaternion_Mean[qr];";
   }
 
   if (m_Controls->m_settionQuaternionStabw->isChecked())
   {
     m_CurrentWriteFile << "Quaternion_StandDev[qx];";
     m_CurrentWriteFile << "Quaternion_StandDev[qy];";
     m_CurrentWriteFile << "Quaternion_StandDev[qz];";
     m_CurrentWriteFile << "Quaternion_StandDev[qr];";
   }
 
   if (m_Controls->m_settingPosErrorMean->isChecked()) m_CurrentWriteFile << "PositionError_Mean;";
 
   if (m_Controls->m_settingPosErrorStabw->isChecked()) m_CurrentWriteFile << "PositionError_StandDev;";
 
   if (m_Controls->m_settingPosErrorSampleStabw->isChecked()) m_CurrentWriteFile << "PositionError_SampleStandDev;";
 
   if (m_Controls->m_settingPosErrorRMS->isChecked()) m_CurrentWriteFile << "PositionError_RMS;";
 
   if (m_Controls->m_settingPosErrorMedian->isChecked()) m_CurrentWriteFile << "PositionError_Median;";
 
   if (m_Controls->m_settingPosErrorMinMax->isChecked())
   {
     m_CurrentWriteFile << "PositionError_Max;";
     m_CurrentWriteFile << "PositionError_Min;";
   }
 
   if (m_Controls->m_settingEulerMean->isChecked())
   {
     m_CurrentWriteFile << "Euler_tx;";
     m_CurrentWriteFile << "Euler_ty;";
     m_CurrentWriteFile << "Euler_tz;";
   }
 
   if (m_Controls->m_settingEulerRMS->isChecked())
   {
     m_CurrentWriteFile << "EulerErrorRMS (rad);";
     m_CurrentWriteFile << "EulerErrorRMS (grad);";
   }
 
   m_CurrentWriteFile << "\n";
 }
 
 void QmitkIGTTrackingDataEvaluationView::WriteDataSet(mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter, std::string dataSetName)
 {
   if (myEvaluationFilter->GetNumberOfOutputs() == 0) m_CurrentWriteFile << "Error: no input \n";
   else
   {
     m_CurrentWriteFile << dataSetName << ";";
     m_CurrentWriteFile << myEvaluationFilter->GetNumberOfAnalysedNavigationData(0) << ";";
     m_CurrentWriteFile << myEvaluationFilter->GetNumberOfInvalidSamples(0) << ";";
     m_CurrentWriteFile << myEvaluationFilter->GetPercentageOfInvalidSamples(0) << ";";
 
     if (m_Controls->m_settingPosMean->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetPositionMean(0)[0] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionMean(0)[1] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionMean(0)[2] << ";";
     }
 
     if (m_Controls->m_settingPosStabw->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetPositionStandardDeviation(0)[0] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionStandardDeviation(0)[1] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionStandardDeviation(0)[2] << ";";
     }
 
     if (m_Controls->m_settingPosSampleStabw->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetPositionSampleStandardDeviation(0)[0] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionSampleStandardDeviation(0)[1] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionSampleStandardDeviation(0)[2] << ";";
     }
 
     if (m_Controls->m_settingQuaternionMean->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionMean(0).x() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionMean(0).y() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionMean(0).z() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionMean(0).r() << ";";
     }
 
     if (m_Controls->m_settionQuaternionStabw->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionStandardDeviation(0).x() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionStandardDeviation(0).y() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionStandardDeviation(0).z() << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetQuaternionStandardDeviation(0).r() << ";";
     }
 
     if (m_Controls->m_settingPosErrorMean->isChecked()) m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorMean(0) << ";";
     if (m_Controls->m_settingPosErrorStabw->isChecked()) m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorStandardDeviation(0) << ";";
     if (m_Controls->m_settingPosErrorSampleStabw->isChecked()) m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorSampleStandardDeviation(0) << ";";
     if (m_Controls->m_settingPosErrorRMS->isChecked()) m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorRMS(0) << ";";
     if (m_Controls->m_settingPosErrorMedian->isChecked()) m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorMedian(0) << ";";
     if (m_Controls->m_settingPosErrorMinMax->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorMax(0) << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetPositionErrorMin(0) << ";";
     }
 
     if (m_Controls->m_settingEulerMean->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetEulerAnglesMean(0)[0] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetEulerAnglesMean(0)[1] << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetEulerAnglesMean(0)[2] << ";";
     }
 
     if (m_Controls->m_settingEulerRMS->isChecked())
     {
       m_CurrentWriteFile << myEvaluationFilter->GetEulerAnglesRMS(0) << ";";
       m_CurrentWriteFile << myEvaluationFilter->GetEulerAnglesRMSDegree(0) << ";";
     }
 
     m_CurrentWriteFile << "\n";
   }
 }
 
 
 std::vector<mitk::Quaternion> QmitkIGTTrackingDataEvaluationView::GetMeanOrientationsOfAllData(std::vector<mitk::NavigationDataEvaluationFilter::Pointer> allData, bool useSLERP)
 {
   std::vector<mitk::Quaternion> returnValue;
 
   for (auto dataSet : allData)
   {
     if (useSLERP) returnValue.push_back(GetSLERPAverage(dataSet));
     else returnValue.push_back(dataSet->GetQuaternionMean(0));
   }
 
   return returnValue;
 }
 
 
 std::vector<mitk::NavigationDataEvaluationFilter::Pointer> QmitkIGTTrackingDataEvaluationView::GetAllDataFromUIList()
 {
   std::vector<mitk::NavigationDataEvaluationFilter::Pointer> EvaluationDataCollection;
 
   //start loop and iterate through all files of list: store the evaluation data
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     //create navigation data player
     mitk::NavigationDataCSVSequentialPlayer::Pointer myPlayer = ConstructNewNavigationDataPlayer();
     myPlayer->SetFiletype(mitk::NavigationDataCSVSequentialPlayer::ManualLoggingCSV);
     myPlayer->SetFileName(m_FilenameVector.at(i));
 
     //create evaluation filter
     mitk::NavigationDataEvaluationFilter::Pointer myEvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 
     //connect pipeline
     for (unsigned int j = 0; j < myPlayer->GetNumberOfOutputs(); ++j)
       myEvaluationFilter->SetInput(j, myPlayer->GetOutput(j));
 
     //update pipline until number of samlples is reached
     for (int j = 0; j < m_Controls->m_NumberOfSamples->value(); ++j)
       myEvaluationFilter->Update();
 
     myEvaluationFilter->SetInput(nullptr);
     myPlayer = nullptr;
     EvaluationDataCollection.push_back(myEvaluationFilter);
   }
 
   return EvaluationDataCollection;
 }
 
 void QmitkIGTTrackingDataEvaluationView::CalculateDifferenceAngles()
 {
   //Get all data from UI
   std::vector<mitk::NavigationDataEvaluationFilter::Pointer> EvaluationDataCollection = GetAllDataFromUIList();
 
   //calculation and writing of output data
   //open output file
   m_CurrentAngleDifferencesWriteFile.open(std::string((m_Controls->m_OutputFilename->text() + ".angledifferences.csv").toUtf8()).c_str(), std::ios::out);
   if (m_CurrentAngleDifferencesWriteFile.bad())
   {
     MessageBox("Error: Can't open output file for angle differences calculation!");
     return;
   }
   //write header
   WriteDifferenceAnglesHeader();
   //compute angle differences
   QString pos1 = "invalid";
   QString pos2 = "invalid";
   //now iterate through all evaluation data and calculate the angles
   for (std::size_t i = 0; i < m_FilenameVector.size(); ++i)
   {
     pos1 = QString::fromStdString(itksys::SystemTools::GetFilenameWithoutLastExtension(m_FilenameVector.at(i)));
     for (std::size_t j = 0; j < m_FilenameVector.size(); ++j)
     {
       pos2 = QString::fromStdString(itksys::SystemTools::GetFilenameWithoutLastExtension(m_FilenameVector.at(j)));
 
       mitk::Quaternion q1;
       mitk::Quaternion q2;
 
       if (m_Controls->m_DifferencesSLERP->isChecked())
       {
         //compute slerp average
         q1 = GetSLERPAverage(EvaluationDataCollection.at(i));
         q2 = GetSLERPAverage(EvaluationDataCollection.at(j));
       }
       else
       {
         //compute arithmetic average
         q1 = EvaluationDataCollection.at(i)->GetQuaternionMean(0);
         q2 = EvaluationDataCollection.at(j)->GetQuaternionMean(0);
       }
 
       itk::Vector<double> rotationVec;
       //adapt for Aurora 5D tools: [0,0,1000]
       rotationVec[0] = 10000; //X
       rotationVec[1] = 0; //Y
       rotationVec[2] = 0; //Z
       double AngleBetweenTwoQuaternions = mitk::StaticIGTHelperFunctions::GetAngleBetweenTwoQuaterions(q1, q2, rotationVec);
 
       //write data set
       WriteDifferenceAnglesDataSet(pos1.toStdString(), pos2.toStdString(), i, j, AngleBetweenTwoQuaternions);
     }
   }
 
   //close output file
   m_CurrentAngleDifferencesWriteFile.close();
 }
 
 void QmitkIGTTrackingDataEvaluationView::WriteDifferenceAnglesHeader()
 {
   m_CurrentAngleDifferencesWriteFile << "Name;Idx1;Idx2;Angle [Degree]\n";
 }
 
 void QmitkIGTTrackingDataEvaluationView::WriteDifferenceAnglesDataSet(std::string pos1, std::string pos2, int idx1, int idx2, double angle)
 {
   m_CurrentAngleDifferencesWriteFile << "Angle between " << pos1 << " and " << pos2 << ";" << idx1 << ";" << idx2 << ";" << angle << "\n";
   MITK_INFO << "Angle: " << angle;
 }
 
 std::vector<mitk::NavigationData::Pointer> QmitkIGTTrackingDataEvaluationView::GetNavigationDatasFromFile(std::string filename)
 {
   std::vector<mitk::NavigationData::Pointer> returnValue = std::vector<mitk::NavigationData::Pointer>();
   std::vector<std::string> fileContentLineByLine = GetFileContentLineByLine(filename);
   for (std::size_t i = 1; i < fileContentLineByLine.size(); ++i) //skip header so start at 1
   {
     returnValue.push_back(GetNavigationDataOutOfOneLine(fileContentLineByLine.at(i)));
   }
 
   return returnValue;
 }
 
 std::vector<std::string> QmitkIGTTrackingDataEvaluationView::GetFileContentLineByLine(std::string filename)
 {
   std::vector<std::string> readData = std::vector<std::string>();
 
   //save old locale
   char * oldLocale;
   oldLocale = setlocale(LC_ALL, nullptr);
 
   //define own locale
   std::locale C("C");
   setlocale(LC_ALL, "C");
 
   //read file
   std::ifstream file;
   file.open(filename.c_str(), std::ios::in);
   if (file.good())
   {
     //read out file
     file.seekg(0L, std::ios::beg);  // move to begin of file
     while (!file.eof())
     {
       std::string buffer;
       std::getline(file, buffer);    // read out file line by line
       if (buffer.size() > 0) readData.push_back(buffer);
     }
   }
 
   file.close();
 
   //switch back to old locale
   setlocale(LC_ALL, oldLocale);
 
   return readData;
 }
 
 mitk::NavigationData::Pointer QmitkIGTTrackingDataEvaluationView::GetNavigationDataOutOfOneLine(std::string line)
 {
   mitk::NavigationData::Pointer returnValue = mitk::NavigationData::New();
 
   QString myLine = QString(line.c_str());
 
   QStringList myLineList = myLine.split(';');
 
   mitk::Point3D position;
   mitk::Quaternion orientation;
 
   bool valid = false;
   if (myLineList.at(2).toStdString() == "1") valid = true;
 
   position[0] = myLineList.at(3).toDouble();
   position[1] = myLineList.at(4).toDouble();
   position[2] = myLineList.at(5).toDouble();
 
   orientation[0] = myLineList.at(6).toDouble();
   orientation[1] = myLineList.at(7).toDouble();
   orientation[2] = myLineList.at(8).toDouble();
   orientation[3] = myLineList.at(9).toDouble();
 
   returnValue->SetDataValid(valid);
   returnValue->SetPosition(position);
   returnValue->SetOrientation(orientation);
 
   return returnValue;
 }
 
 mitk::Quaternion QmitkIGTTrackingDataEvaluationView::GetSLERPAverage(mitk::NavigationDataEvaluationFilter::Pointer evaluationFilter)
 {
   mitk::Quaternion average;
 
   //build a vector of quaternions from the evaulation filter (caution always takes the first (0) input of the filter
   std::vector<mitk::Quaternion> quaternions = std::vector<mitk::Quaternion>();
   for (int i = 0; i < evaluationFilter->GetNumberOfAnalysedNavigationData(0); i++)
   {
     mitk::Quaternion currentq = evaluationFilter->GetLoggedOrientation(i, 0);
 
     quaternions.push_back(currentq);
   }
 
   //compute the slerp average using the quaternion averaging class
   mitk::QuaternionAveraging::Pointer myAverager = mitk::QuaternionAveraging::New();
   average = myAverager->CalcAverage(quaternions);
 
   return average;
 }
 
 void QmitkIGTTrackingDataEvaluationView::writeToFile(std::string filename, std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> values)
 {
   std::fstream currentFile;
   currentFile.open(filename.c_str(), std::ios::out);
   if (currentFile.bad()) { MITK_WARN << "Cannot open file, aborting!"; return; }
   currentFile << "Description" << ";" << "Error[mm]" << "\n";
   for (auto currentError : values)
   {
     currentFile << currentError.description << ";" << currentError.distanceError << "\n";
   }
   currentFile.close();
 }
 
 mitk::NavigationDataCSVSequentialPlayer::Pointer QmitkIGTTrackingDataEvaluationView::ConstructNewNavigationDataPlayer()
 {
     bool rightHanded = m_Controls->m_RigthHanded->isChecked();
     QString separator =  m_Controls->m_SeparatorSign->text();
     QChar sepaSign = separator.at(0);
     //char separatorSign;
     char separatorSign = sepaSign.toLatin1();
     //std::string separatorSign = m_Controls->m_SeparatorSign->text().toStdString();
     int sampleCount = m_Controls->m_SampleCount->value();
     bool headerRow = m_Controls->m_HeaderRow->isChecked();
     int xPos = m_Controls->m_XPos->value();
     int yPos = m_Controls->m_YPos->value();
     int zPos = m_Controls->m_ZPos->value();
     bool useQuats = m_Controls->m_UseQuats->isChecked();
     int qx = m_Controls->m_Qx->value();
     int qy = m_Controls->m_Qy->value();
     int qz = m_Controls->m_Qz->value();
     int qr = m_Controls->m_Qr->value();
     int azimuth = m_Controls->m_Azimuth->value();
     int elevation = m_Controls->m_Elevation->value();
     int roll = m_Controls->m_Roll->value();
     bool eulersInRad = m_Controls->m_Radiants->isChecked();
     //need to find the biggest column number to determine the  minimal number of columns the .csv file has to have
     int allInts[] = {xPos, yPos, zPos, qx, qy, qr, azimuth, elevation, roll};
     int minNumberOfColumns = (*std::max_element(allInts, allInts+9)+1); //size needs to be +1 because columns start at 0 but size at 1
 
     mitk::NavigationDataCSVSequentialPlayer::Pointer navDataPlayer = mitk::NavigationDataCSVSequentialPlayer::New();
     navDataPlayer->SetOptions(rightHanded, separatorSign, sampleCount, headerRow, xPos, yPos, zPos, useQuats,
                               qx, qy, qz, qr, azimuth, elevation, roll, eulersInRad, minNumberOfColumns);
     return navDataPlayer;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.h b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.h
index fce8ea93d0..e83f5bc590 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingDataEvaluationView.h
@@ -1,139 +1,128 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkIGTTrackingDataEvaluationView_h
 #define QmitkIGTTrackingDataEvaluationView_h
 
 #include <berryISelectionListener.h>
 
-#include <QmitkFunctionality.h>
-#include <QmitkStdMultiWidget.h>
+#include <QmitkAbstractView.h>
 
 #include "ui_QmitkIGTTrackingDataEvaluationViewControls.h"
 #include "mitkHummelProtocolEvaluation.h"
 
 #include <mitkNavigationDataEvaluationFilter.h>
 #include "mitkNavigationDataCSVSequentialPlayer.h"
 
-
-
 /*!
   \brief QmitkIGTTrackingDataEvaluationView
 
   \warning  This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation.
 
-  \sa QmitkFunctionality
-  \ingroup Functionalities
 */
-class QmitkIGTTrackingDataEvaluationView : public QmitkFunctionality
+class QmitkIGTTrackingDataEvaluationView : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkIGTTrackingDataEvaluationView();
     ~QmitkIGTTrackingDataEvaluationView() override;
 
     void CreateQtPartControl(QWidget *parent) override;
-
-    virtual void MultiWidgetAvailable(QmitkAbstractMultiWidget &multiWidget) override;
-    virtual void MultiWidgetNotAvailable() override;
+    void SetFocus() override {}
 
   protected slots:
 
     void OnLoadFileList();
     void OnAddToCurrentList();
     void OnEvaluateData();
     void OnEvaluateDataAll();
     void OnGeneratePointSet();
     void OnGeneratePointSetsOfSinglePositions();
     void OnGenerateRotationLines();
     void OnGenerateGroundTruthPointSet();
     void OnConvertCSVtoXMLFile();
     void OnCSVtoXMLLoadInputList();
     void OnCSVtoXMLLoadOutputList();
     void OnPerfomGridMatching();
     void OnComputeRotation();
 
     /** Reads in exactly three position files als reference. */
     void OnOrientationCalculation_CalcRef();
     /** Uses always three positions (1,2,3: first orientation; 4,5,6: second orientation; and so on) in every file to calcualte a orientation. */
     void OnOrientationCalculation_CalcOrientandWriteToFile();
 
 
   protected:
 
     Ui::QmitkIGTTrackingDataEvaluationViewControls* m_Controls;
 
-    QmitkStdMultiWidget* m_MultiWidget;
-
     std::vector<std::string> m_FilenameVector;
 
     void MessageBox(std::string s);
 
     std::fstream m_CurrentWriteFile;
     void WriteHeader();
     void WriteDataSet(mitk::NavigationDataEvaluationFilter::Pointer evaluationFilter, std::string dataSetName);
 
     //members for orientation calculation
     mitk::Point3D m_RefPoint1;
     mitk::Point3D m_RefPoint2;
     mitk::Point3D m_RefPoint3;
 
     double m_scalingfactor; //scaling factor for visualization, 1 by default
 
     //angle diffrences: seperated file
     std::fstream m_CurrentAngleDifferencesWriteFile;
     void CalculateDifferenceAngles();
     void WriteDifferenceAnglesHeader();
     void WriteDifferenceAnglesDataSet(std::string pos1, std::string pos2, int idx1, int idx2, double angle);
 
     void writeToFile(std::string filename, std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> values);
 
     //different help methods to read a csv logging file
     std::vector<mitk::NavigationData::Pointer> GetNavigationDatasFromFile(std::string filename);
     std::vector<std::string> GetFileContentLineByLine(std::string filename);
     mitk::NavigationData::Pointer GetNavigationDataOutOfOneLine(std::string line);
 
     //help method to sonstruct the NavigationDataCSVSequentialPlayer filled with all the options from the UI
     mitk::NavigationDataCSVSequentialPlayer::Pointer ConstructNewNavigationDataPlayer();
 
     //CSV to XML members
     std::vector<std::string> m_CSVtoXMLInputFilenameVector;
     std::vector<std::string> m_CSVtoXMLOutputFilenameVector;
 
     //returns the number of converted lines
     int ConvertOneFile(std::string inputFilename, std::string outputFilename);
 
     /** @brief calculates the angle in the plane perpendicular to the rotation axis of the two quaterions. */
     double GetAngleBetweenTwoQuaterions(mitk::Quaternion a, mitk::Quaternion b);
 
     /** @brief calculates the slerp average of a set of quaternions which is stored in the navigation data evaluation filter */
     mitk::Quaternion GetSLERPAverage(mitk::NavigationDataEvaluationFilter::Pointer);
 
     /** @brief Stores the mean positions of all evaluated data */
     mitk::PointSet::Pointer m_PointSetMeanPositions;
 
     /** @return returns the mean orientation of all given data */
     std::vector<mitk::Quaternion> GetMeanOrientationsOfAllData(std::vector<mitk::NavigationDataEvaluationFilter::Pointer> allData, bool useSLERP = false);
 
     /** @return returns all data read from the data list as NavigationDataEvaluationFilters */
     std::vector<mitk::NavigationDataEvaluationFilter::Pointer> GetAllDataFromUIList();
 };
 
 
 
 #endif // _QMITKIGTTRACKINGDATAEVALUATIONVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.cpp b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.cpp
index 4c14d4c333..85bbb1257e 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.cpp
@@ -1,618 +1,606 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkIGTTrackingSemiAutomaticMeasurementView.h"
 
 // Qt
 #include <QMessageBox>
 #include <qfiledialog.h>
 #include <qevent.h>
 #include <QCheckBox>
 
 // MITK
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkTrackingDeviceSourceConfigurator.h>
 #include <mitkLog.h>
 #include "mitkHummelProtocolEvaluation.h"
 
 // POCO
 #include <Poco/File.h>
 #include <Poco/Path.h>
 
 const std::string QmitkIGTTrackingSemiAutomaticMeasurementView::VIEW_ID = "org.mitk.views.igttrackingsemiautomaticmeasurement";
 
 QmitkIGTTrackingSemiAutomaticMeasurementView::QmitkIGTTrackingSemiAutomaticMeasurementView()
-  : QmitkFunctionality()
-  , m_Controls(nullptr)
-  , m_MultiWidget(nullptr)
+  : m_Controls(nullptr)
 {
   m_NextFile = 0;
   m_FilenameVector = std::vector<std::string>();
   m_Timer = new QTimer(this);
   m_logging = false;
   m_referenceValid = true;
   m_tracking = false;
   m_EvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
 }
 
 QmitkIGTTrackingSemiAutomaticMeasurementView::~QmitkIGTTrackingSemiAutomaticMeasurementView()
 {
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::CreateResults()
 {
   QString LogFileName = m_Controls->m_OutputPath->text() + "_results.log";
   mitk::LoggingBackend::Unregister();
   mitk::LoggingBackend::SetLogFile(LogFileName.toStdString().c_str());
   mitk::LoggingBackend::Register();
 
   double RMSmean = 0;
   for (std::size_t i = 0; i < m_RMSValues.size(); ++i)
   {
     MITK_INFO << "RMS at " << this->m_FilenameVector.at(i) << ": " << m_RMSValues.at(i);
     RMSmean += m_RMSValues.at(i);
   }
   RMSmean /= m_RMSValues.size();
   MITK_INFO << "RMS mean over " << m_RMSValues.size() << " values: " << RMSmean;
 
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName("Tracking Results");
   newNode->SetData(this->m_MeanPoints);
   this->GetDataStorage()->Add(newNode);
 
   std::vector<mitk::HummelProtocolEvaluation::HummelProtocolDistanceError> results5cmDistances;
   if (m_Controls->m_mediumVolume->isChecked())
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_MeanPoints, mitk::HummelProtocolEvaluation::medium, results5cmDistances);
   else if (m_Controls->m_smallVolume->isChecked())
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_MeanPoints, mitk::HummelProtocolEvaluation::small, results5cmDistances);
   else if (m_Controls->m_standardVolume->isChecked())
     mitk::HummelProtocolEvaluation::Evaluate5cmDistances(m_MeanPoints, mitk::HummelProtocolEvaluation::standard, results5cmDistances);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::CreateQtPartControl(QWidget *parent)
 {
   // build up qt view, unless already done
   if (!m_Controls)
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkIGTTrackingSemiAutomaticMeasurementViewControls;
     m_Controls->setupUi(parent);
 
     //buttons
     connect(m_Controls->m_LoadMeasurementToolStorage, SIGNAL(clicked()), this, SLOT(OnLoadMeasurementStorage()));
     connect(m_Controls->m_LoadReferenceToolStorage, SIGNAL(clicked()), this, SLOT(OnLoadReferenceStorage()));
     connect(m_Controls->m_StartTracking, SIGNAL(clicked()), this, SLOT(OnStartTracking()));
     connect(m_Controls->m_LoadList, SIGNAL(clicked()), this, SLOT(OnMeasurementLoadFile()));
     connect(m_Controls->m_StartNextMeasurement, SIGNAL(clicked()), this, SLOT(StartNextMeasurement()));
     connect(m_Controls->m_ReapeatLastMeasurement, SIGNAL(clicked()), this, SLOT(RepeatLastMeasurement()));
     connect(m_Controls->m_SetReference, SIGNAL(clicked()), this, SLOT(OnSetReference()));
     connect(m_Controls->m_UseReferenceTrackingSystem, SIGNAL(toggled(bool)), this, SLOT(OnUseReferenceToggled(bool)));
     connect(m_Controls->m_CreateResults, SIGNAL(clicked()), this, SLOT(CreateResults()));
 
     //event filter
     qApp->installEventFilter(this);
 
     //timers
     connect(m_Timer, SIGNAL(timeout()), this, SLOT(UpdateTimer()));
   }
 
   //initialize some view
   m_Controls->m_StopTracking->setEnabled(false);
 }
 
-void QmitkIGTTrackingSemiAutomaticMeasurementView::MultiWidgetAvailable(QmitkAbstractMultiWidget &multiWidget)
-{
-  m_MultiWidget = dynamic_cast<QmitkStdMultiWidget*>(&multiWidget);
-}
-
-void QmitkIGTTrackingSemiAutomaticMeasurementView::MultiWidgetNotAvailable()
-{
-  m_MultiWidget = nullptr;
-}
-
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnUseReferenceToggled(bool state)
 {
   if (state)
   {
     m_Controls->m_ReferenceBox->setEnabled(true);
     m_Controls->m_SetReference->setEnabled(true);
   }
 
   else
   {
     m_Controls->m_ReferenceBox->setEnabled(false);
     m_Controls->m_SetReference->setEnabled(false);
   }
 }
 
 mitk::NavigationToolStorage::Pointer QmitkIGTTrackingSemiAutomaticMeasurementView::ReadStorage(std::string file)
 {
   mitk::NavigationToolStorage::Pointer returnValue;
 
   //initialize tool storage
   returnValue = mitk::NavigationToolStorage::New();
 
   //read tool storage from disk
   mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
   returnValue = myDeserializer->Deserialize(file);
   if (returnValue.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText(myDeserializer->GetErrorMessage().c_str());
     msgBox.exec();
 
     returnValue = nullptr;
   }
 
   return returnValue;
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnSetReference()
 {
   //initialize reference
   m_ReferenceStartPositions = std::vector<mitk::Point3D>();
   m_ReferenceTrackingDeviceSource->Update();
   QString Label = "Positions At Start: ";
   for (unsigned int i = 0; i < m_ReferenceTrackingDeviceSource->GetNumberOfOutputs(); ++i)
   {
     mitk::Point3D position = m_ReferenceTrackingDeviceSource->GetOutput(i)->GetPosition();
     Label = Label + "Tool" + QString::number(i) + ":[" + QString::number(position[0]) + ":" + QString::number(position[1]) + ":" + QString::number(position[1]) + "] ";
     m_ReferenceStartPositions.push_back(position);
   }
   m_Controls->m_ReferencePosAtStart->setText(Label);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnLoadMeasurementStorage()
 {
   //read in filename
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Toolfile"), "/", tr("All Files (*.*)"));
   if (filename.isNull()) return;
 
   m_MeasurementStorage = ReadStorage(filename.toStdString());
 
   //update label
   Poco::Path myPath = Poco::Path(filename.toStdString()); //use this to seperate filename from path
   QString toolLabel = QString("Tool Storage: ") + QString::number(m_MeasurementStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
   m_Controls->m_MeasurementToolStorageLabel->setText(toolLabel);
 
   //update status widget
   m_Controls->m_ToolStatusWidget->RemoveStatusLabels();
   m_Controls->m_ToolStatusWidget->PreShowTools(m_MeasurementStorage);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnLoadReferenceStorage()
 {
   //read in filename
   static QString oldFile;
   if (oldFile.isNull()) oldFile = "/";
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Toolfile"), oldFile, tr("All Files (*.*)"));
   if (filename.isNull()) return;
   oldFile = filename;
 
   m_ReferenceStorage = ReadStorage(filename.toStdString());
 
   //update label
   Poco::Path myPath = Poco::Path(filename.toStdString()); //use this to seperate filename from path
   QString toolLabel = QString("Tool Storage: ") + QString::number(m_ReferenceStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
   m_Controls->m_ReferenceToolStorageLabel->setText(toolLabel);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnStartTracking()
 {
   //check if everything is ready to start tracking
   if (m_MeasurementStorage.IsNull())
   {
     MessageBox("Error: No measurement tools loaded yet!");
     return;
   }
   else if (m_ReferenceStorage.IsNull() && m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     MessageBox("Error: No refernce tools loaded yet!");
     return;
   }
   else if (m_MeasurementStorage->GetToolCount() == 0)
   {
     MessageBox("Error: No way to track without tools!");
     return;
   }
   else if (m_Controls->m_UseReferenceTrackingSystem->isChecked() && (m_ReferenceStorage->GetToolCount() == 0))
   {
     MessageBox("Error: No way to track without tools!");
     return;
   }
 
   //build the first IGT pipeline (MEASUREMENT)
   mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory1 = mitk::TrackingDeviceSourceConfigurator::New(this->m_MeasurementStorage, this->m_Controls->m_MeasurementTrackingDeviceConfigurationWidget->GetTrackingDevice());
   m_MeasurementTrackingDeviceSource = myTrackingDeviceSourceFactory1->CreateTrackingDeviceSource(this->m_MeasurementToolVisualizationFilter);
   if (m_MeasurementTrackingDeviceSource.IsNull())
   {
     MessageBox(myTrackingDeviceSourceFactory1->GetErrorMessage());
     return;
   }
   //connect the tool visualization widget
   for (unsigned int i = 0; i < m_MeasurementTrackingDeviceSource->GetNumberOfOutputs(); ++i)
   {
     m_Controls->m_ToolStatusWidget->AddNavigationData(m_MeasurementTrackingDeviceSource->GetOutput(i));
     m_EvaluationFilter->SetInput(i, m_MeasurementTrackingDeviceSource->GetOutput(i));
   }
   m_Controls->m_ToolStatusWidget->ShowStatusLabels();
   m_Controls->m_ToolStatusWidget->SetShowPositions(true);
   m_Controls->m_ToolStatusWidget->SetShowQuaternions(true);
 
   //build the second IGT pipeline (REFERENCE)
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory2 = mitk::TrackingDeviceSourceConfigurator::New(this->m_ReferenceStorage, this->m_Controls->m_ReferenceDeviceConfigurationWidget->GetTrackingDevice());
     m_ReferenceTrackingDeviceSource = myTrackingDeviceSourceFactory2->CreateTrackingDeviceSource();
     if (m_ReferenceTrackingDeviceSource.IsNull())
     {
       MessageBox(myTrackingDeviceSourceFactory2->GetErrorMessage());
       return;
     }
   }
 
   //initialize tracking
   try
   {
     m_MeasurementTrackingDeviceSource->Connect();
     m_MeasurementTrackingDeviceSource->StartTracking();
     if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
     {
       m_ReferenceTrackingDeviceSource->Connect();
       m_ReferenceTrackingDeviceSource->StartTracking();
     }
   }
   catch (...)
   {
     MessageBox("Error while starting the tracking device!");
     return;
   }
 
   //set reference
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked()) OnSetReference();
 
   //start timer
   m_Timer->start(1000 / (m_Controls->m_SamplingRate->value()));
 
   m_Controls->m_StartTracking->setEnabled(false);
   m_Controls->m_StartTracking->setEnabled(true);
 
   m_tracking = true;
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnStopTracking()
 {
   if (this->m_logging) FinishMeasurement();
   m_MeasurementTrackingDeviceSource->Disconnect();
   m_MeasurementTrackingDeviceSource->StopTracking();
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     m_ReferenceTrackingDeviceSource->Disconnect();
     m_ReferenceTrackingDeviceSource->StopTracking();
   }
   m_Timer->stop();
   m_Controls->m_StartTracking->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(false);
   m_tracking = false;
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::OnMeasurementLoadFile()
 {
   m_FilenameVector = std::vector<std::string>();
   m_FilenameVector.clear();
   m_NextFile = 0;
 
   //read in filename
   QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Measurement Filename List"), "/", tr("All Files (*.*)"));
   if (filename.isNull()) return;
 
   //define own locale
   std::locale C("C");
   setlocale(LC_ALL, "C");
 
   //read file
   std::ifstream file;
   file.open(filename.toStdString().c_str(), std::ios::in);
   if (file.good())
   {
     //read out file
     file.seekg(0L, std::ios::beg);  // move to begin of file
     while (!file.eof())
     {
       std::string buffer;
       std::getline(file, buffer);    // read out file line by line
       if (buffer.size() > 0) m_FilenameVector.push_back(buffer);
     }
   }
 
   //fill list at GUI
   m_Controls->m_MeasurementList->clear();
   for (unsigned int i = 0; i < m_FilenameVector.size(); i++) { new QListWidgetItem(tr(m_FilenameVector.at(i).c_str()), m_Controls->m_MeasurementList); }
 
   //update label next measurement
   std::stringstream label;
   label << "Next Measurement: " << m_FilenameVector.at(0);
   m_Controls->m_NextMeasurement->setText(label.str().c_str());
 
   //reset results files
   m_MeanPoints = mitk::PointSet::New();
   m_RMSValues = std::vector<double>();
   m_EvaluationFilter = mitk::NavigationDataEvaluationFilter::New();
   if (m_MeasurementToolVisualizationFilter.IsNotNull()) m_EvaluationFilter->SetInput(0, m_MeasurementToolVisualizationFilter->GetOutput(0));
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::UpdateTimer()
 {
   if (m_EvaluationFilter.IsNotNull() && m_logging) m_EvaluationFilter->Update();
   else m_MeasurementToolVisualizationFilter->Update();
 
   m_Controls->m_ToolStatusWidget->Refresh();
 
   //update reference
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     m_ReferenceTrackingDeviceSource->Update();
     QString Label = "Current Positions: ";
     bool distanceThresholdExceeded = false;
     for (unsigned int i = 0; i < m_ReferenceTrackingDeviceSource->GetNumberOfOutputs(); ++i)
     {
       mitk::Point3D position = m_ReferenceTrackingDeviceSource->GetOutput(i)->GetPosition();
       Label = Label + "Tool" + QString::number(i) + ":[" + QString::number(position[0]) + ":" + QString::number(position[1]) + ":" + QString::number(position[1]) + "] ";
       if (position.EuclideanDistanceTo(m_ReferenceStartPositions.at(i)) > m_Controls->m_ReferenceThreshold->value()) distanceThresholdExceeded = true;
     }
     m_Controls->m_ReferenceCurrentPos->setText(Label);
     if (distanceThresholdExceeded)
     {
       m_Controls->m_ReferenceOK->setText("<html><body style=\" font-family:\'MS Shell Dlg 2\'; font-size:28pt; font-weight:400; font-style:normal;\">NOT OK!</body></html>");
       m_referenceValid = false;
     }
     else
     {
       m_Controls->m_ReferenceOK->setText("<html><body style=\" font-family:\'MS Shell Dlg 2\'; font-size:28pt; font-weight:400; font-style:normal;\">OK</body></html>");
       m_referenceValid = true;
     }
   }
 
   //update logging
   if (m_logging)
   {
     //check for missing objects
     if (m_MeasurementLoggingFilterXML.IsNull() ||
       m_MeasurementLoggingFilterCSV.IsNull()
       )
     {
       return;
     }
 
     //log/measure
     m_MeasurementLoggingFilterXML->Update();
     m_MeasurementLoggingFilterCSV->Update();
 
     if (m_Controls->m_UseReferenceTrackingSystem->isChecked() &&
       m_ReferenceLoggingFilterXML.IsNotNull() &&
       m_ReferenceLoggingFilterCSV.IsNotNull())
     {
       m_ReferenceLoggingFilterXML->Update();
       m_ReferenceLoggingFilterCSV->Update();
     }
     m_loggedFrames++;
     LogAdditionalCSVFile();
 
     //check if all frames are logged ... if yes finish the measurement
     if (m_loggedFrames > m_Controls->m_SamplesPerMeasurement->value()) { FinishMeasurement(); }
 
     //update logging label
     QString loggingLabel = "Collected Samples: " + QString::number(m_loggedFrames);
     m_Controls->m_CollectedSamples->setText(loggingLabel);
   }
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::StartNextMeasurement()
 {
   if (this->m_NextFile >= static_cast<int>(m_FilenameVector.size()))
   {
     MessageBox("Last Measurement reached!");
     return;
   }
 
   m_loggedFrames = 0;
   m_logging = true;
 
   //check if directory exists, if not create one
   Poco::File myPath(std::string(m_Controls->m_OutputPath->text().toUtf8()).c_str());
   if (!myPath.exists()) myPath.createDirectory();
 
   QString LogFileName = m_Controls->m_OutputPath->text() + QString(m_FilenameVector.at(m_NextFile).c_str()) + ".log";
   mitk::LoggingBackend::Unregister();
   mitk::LoggingBackend::SetLogFile(LogFileName.toStdString().c_str());
   mitk::LoggingBackend::Register();
 
   //initialize logging filters
   m_MeasurementLoggingFilterXML = mitk::NavigationDataRecorderDeprecated::New();
   m_MeasurementLoggingFilterXML->SetRecordingMode(mitk::NavigationDataRecorderDeprecated::NormalFile);
   m_MeasurementLoggingFilterCSV = mitk::NavigationDataRecorderDeprecated::New();
   m_MeasurementLoggingFilterCSV->SetRecordingMode(mitk::NavigationDataRecorderDeprecated::NormalFile);
   m_MeasurementLoggingFilterXML->SetOutputFormat(mitk::NavigationDataRecorderDeprecated::xml);
   m_MeasurementLoggingFilterCSV->SetOutputFormat(mitk::NavigationDataRecorderDeprecated::csv);
   QString MeasurementFilenameXML = m_Controls->m_OutputPath->text() + QString(m_FilenameVector.at(m_NextFile).c_str()) + ".xml";
   QString MeasurementFilenameCSV = m_Controls->m_OutputPath->text() + QString(m_FilenameVector.at(m_NextFile).c_str()) + ".csv";
   m_MeasurementLoggingFilterXML->SetFileName(MeasurementFilenameXML.toStdString());
   m_MeasurementLoggingFilterCSV->SetFileName(MeasurementFilenameCSV.toStdString());
   m_MeasurementLoggingFilterXML->SetRecordCountLimit(m_Controls->m_SamplesPerMeasurement->value());
   m_MeasurementLoggingFilterCSV->SetRecordCountLimit(m_Controls->m_SamplesPerMeasurement->value());
 
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     m_ReferenceLoggingFilterXML = mitk::NavigationDataRecorderDeprecated::New();
     m_ReferenceLoggingFilterXML->SetRecordingMode(mitk::NavigationDataRecorderDeprecated::NormalFile);
     m_ReferenceLoggingFilterCSV = mitk::NavigationDataRecorderDeprecated::New();
     m_ReferenceLoggingFilterCSV->SetRecordingMode(mitk::NavigationDataRecorderDeprecated::NormalFile);
     m_ReferenceLoggingFilterXML->SetOutputFormat(mitk::NavigationDataRecorderDeprecated::xml);
     m_ReferenceLoggingFilterCSV->SetOutputFormat(mitk::NavigationDataRecorderDeprecated::csv);
     QString ReferenceFilenameXML = m_Controls->m_OutputPath->text() + "Reference_" + QString(m_FilenameVector.at(m_NextFile).c_str()) + ".xml";
     QString ReferenceFilenameCSV = m_Controls->m_OutputPath->text() + "Reference_" + QString(m_FilenameVector.at(m_NextFile).c_str()) + ".csv";
     m_ReferenceLoggingFilterXML->SetFileName(ReferenceFilenameXML.toStdString());
     m_ReferenceLoggingFilterCSV->SetFileName(ReferenceFilenameCSV.toStdString());
     m_ReferenceLoggingFilterXML->SetRecordCountLimit(m_Controls->m_SamplesPerMeasurement->value());
     m_ReferenceLoggingFilterCSV->SetRecordCountLimit(m_Controls->m_SamplesPerMeasurement->value());
   }
 
   //start additional csv logging
   StartLoggingAdditionalCSVFile(m_FilenameVector.at(m_NextFile));
 
   //connect filter
   for (unsigned int i = 0; i < m_MeasurementToolVisualizationFilter->GetNumberOfOutputs(); ++i)
   {
     m_MeasurementLoggingFilterXML->AddNavigationData(m_MeasurementToolVisualizationFilter->GetOutput(i));
     m_MeasurementLoggingFilterCSV->AddNavigationData(m_MeasurementToolVisualizationFilter->GetOutput(i));
   }
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked()) for (unsigned int i = 0; i < m_ReferenceTrackingDeviceSource->GetNumberOfOutputs(); ++i)
   {
     m_ReferenceLoggingFilterXML->AddNavigationData(m_ReferenceTrackingDeviceSource->GetOutput(i));
     m_ReferenceLoggingFilterCSV->AddNavigationData(m_ReferenceTrackingDeviceSource->GetOutput(i));
   }
 
   //start filter
   m_MeasurementLoggingFilterXML->StartRecording();
   m_MeasurementLoggingFilterCSV->StartRecording();
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     m_ReferenceLoggingFilterXML->StartRecording();
     m_ReferenceLoggingFilterCSV->StartRecording();
   }
 
   //disable all buttons
   DisableAllButtons();
 
   //update label next measurement
   std::stringstream label;
   if ((m_NextFile + 1) >= static_cast<int>(m_FilenameVector.size())) label << "Next Measurement: <none>";
   else label << "Next Measurement: " << m_FilenameVector.at(m_NextFile + 1);
   m_Controls->m_NextMeasurement->setText(label.str().c_str());
 
   //update label last measurement
   std::stringstream label2;
   label2 << "Last Measurement: " << m_FilenameVector.at(m_NextFile);
   m_Controls->m_LastMeasurement->setText(label2.str().c_str());
 
   m_NextFile++;
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::RepeatLastMeasurement()
 {
   m_NextFile--;
   StartNextMeasurement();
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::DisableAllButtons()
 {
   m_Controls->m_LoadList->setEnabled(false);
   m_Controls->m_StartNextMeasurement->setEnabled(false);
   m_Controls->m_ReapeatLastMeasurement->setEnabled(false);
   m_Controls->m_SamplingRate->setEnabled(false);
   m_Controls->m_SamplesPerMeasurement->setEnabled(false);
   m_Controls->m_ReferenceThreshold->setEnabled(false);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::EnableAllButtons()
 {
   m_Controls->m_LoadList->setEnabled(true);
   m_Controls->m_StartNextMeasurement->setEnabled(true);
   m_Controls->m_ReapeatLastMeasurement->setEnabled(true);
   m_Controls->m_SamplingRate->setEnabled(true);
   m_Controls->m_SamplesPerMeasurement->setEnabled(true);
   m_Controls->m_ReferenceThreshold->setEnabled(true);
 }
 
 void QmitkIGTTrackingSemiAutomaticMeasurementView::FinishMeasurement()
 {
   m_logging = false;
 
   m_MeasurementLoggingFilterXML->StopRecording();
   m_MeasurementLoggingFilterCSV->StopRecording();
   if (m_Controls->m_UseReferenceTrackingSystem->isChecked())
   {
     m_ReferenceLoggingFilterXML->StopRecording();
     m_ReferenceLoggingFilterCSV->StopRecording();
   }
   StopLoggingAdditionalCSVFile();
 
   int id = m_NextFile - 1;
   mitk::Point3D positionMean = m_EvaluationFilter->GetPositionMean(0);
   MITK_INFO << "Evaluated " << m_EvaluationFilter->GetNumberOfAnalysedNavigationData(0) << " samples.";
   double rms = m_EvaluationFilter->GetPositionErrorRMS(0);
   MITK_INFO << "RMS: " << rms;
   MITK_INFO << "Position Mean: " << positionMean;
   m_MeanPoints->SetPoint(id, positionMean);
   if (static_cast<int>(m_RMSValues.size()) <= id) m_RMSValues.push_back(rms);
   else m_RMSValues[id] = rms;
 
   m_EvaluationFilter->ResetStatistic();
 
   EnableAllButtons();
 }
 
 void  QmitkIGTTrackingSemiAutomaticMeasurementView::StartLoggingAdditionalCSVFile(std::string filePostfix)
 {
   //write logfile header
   QString header = "Nr;MITK_Time;Valid_Reference;";
   QString tool = QString("MeasureTool_") + QString(m_MeasurementTrackingDeviceSource->GetOutput(0)->GetName());
   header = header + tool + "[x];" + tool + "[y];" + tool + "[z];" + tool + "[qx];" + tool + "[qy];" + tool + "[qz];" + tool + "[qr]\n";
 
   //open logfile and write header
   m_logFileCSV.open(std::string(m_Controls->m_OutputPath->text().toUtf8()).append("/LogFileCombined").append(filePostfix.c_str()).append(".csv").c_str(), std::ios::out);
   m_logFileCSV << header.toStdString().c_str();
 }
 
 void  QmitkIGTTrackingSemiAutomaticMeasurementView::LogAdditionalCSVFile()
 {
   mitk::Point3D pos = m_MeasurementTrackingDeviceSource->GetOutput(0)->GetPosition();
   mitk::Quaternion rot = m_MeasurementTrackingDeviceSource->GetOutput(0)->GetOrientation();
   std::string valid = "";
   if (m_referenceValid) valid = "true";
   else valid = "false";
   std::stringstream timestamp;
   timestamp << m_MeasurementTrackingDeviceSource->GetOutput(0)->GetTimeStamp();
   QString dataSet = QString::number(m_loggedFrames) + ";" + QString(timestamp.str().c_str()) + ";" + QString(valid.c_str()) + ";" + QString::number(pos[0]) + ";" + QString::number(pos[1]) + ";" + QString::number(pos[2]) + ";" + QString::number(rot.x()) + ";" + QString::number(rot.y()) + ";" + QString::number(rot.z()) + ";" + QString::number(rot.r()) + "\n";
   m_logFileCSV << dataSet.toStdString();
 }
 
 void  QmitkIGTTrackingSemiAutomaticMeasurementView::StopLoggingAdditionalCSVFile()
 {
   m_logFileCSV.close();
 }
 
 bool QmitkIGTTrackingSemiAutomaticMeasurementView::eventFilter(QObject *, QEvent *ev)
 {
   if (ev->type() == QEvent::KeyPress)
   {
     QKeyEvent *k = (QKeyEvent *)ev;
     bool down = k->key() == 16777239;
 
     if (down && m_tracking && !m_logging)
       StartNextMeasurement();
   }
 
   return false;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.h b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.h
index f2de6c39d5..44ccea0f48 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/src/internal/QmitkIGTTrackingSemiAutomaticMeasurementView.h
@@ -1,129 +1,120 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkIGTTrackingSemiAutomaticMeasurementView_h
 #define QmitkIGTTrackingSemiAutomaticMeasurementView_h
 
 #include <berryISelectionListener.h>
 
-#include <QmitkFunctionality.h>
-#include <QmitkStdMultiWidget.h>
+#include <QmitkAbstractView.h>
 
 //QT
 #include <QTimer>
 
 //MITK
 #include <mitkNavigationToolStorage.h>
 #include <mitkTrackingDeviceSource.h>
 #include <mitkNavigationDataObjectVisualizationFilter.h>
 #include <mitkNavigationDataRecorderDeprecated.h>
 #include <mitkNavigationDataEvaluationFilter.h>
 
 #include "ui_QmitkIGTTrackingSemiAutomaticMeasurementViewControls.h"
 
 /*!
   \brief QmitkIGTTrackingSemiAutomaticMeasurementView
 
   \warning  This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation.
 
-  \sa QmitkFunctionality
-  \ingroup Functionalities
   */
-class QmitkIGTTrackingSemiAutomaticMeasurementView : public QmitkFunctionality
+class QmitkIGTTrackingSemiAutomaticMeasurementView : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkIGTTrackingSemiAutomaticMeasurementView();
   ~QmitkIGTTrackingSemiAutomaticMeasurementView() override;
 
   void CreateQtPartControl(QWidget *parent) override;
+  void SetFocus() override {}
 
-  virtual void MultiWidgetAvailable(QmitkAbstractMultiWidget &multiWidget) override;
-  virtual void MultiWidgetNotAvailable() override;
-
-  protected slots:
+protected slots:
 
   void OnLoadMeasurementStorage();
   void OnLoadReferenceStorage();
   void OnStartTracking();
   void OnStopTracking();
   void OnMeasurementLoadFile();
   void OnSetReference();
   void StartNextMeasurement();
   void RepeatLastMeasurement();
   void UpdateTimer();
   void CreateResults();
   void OnUseReferenceToggled(bool state);
 
 protected:
 
   Ui::QmitkIGTTrackingSemiAutomaticMeasurementViewControls* m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
-
   //the tool storages
   mitk::NavigationToolStorage::Pointer m_MeasurementStorage;
   mitk::NavigationToolStorage::Pointer m_ReferenceStorage;
 
   //members for the filter pipeline
   mitk::TrackingDeviceSource::Pointer m_MeasurementTrackingDeviceSource;
   mitk::NavigationDataObjectVisualizationFilter::Pointer m_MeasurementToolVisualizationFilter;
   mitk::NavigationDataRecorderDeprecated::Pointer m_MeasurementLoggingFilterXML;
   mitk::NavigationDataRecorderDeprecated::Pointer m_MeasurementLoggingFilterCSV;
   mitk::TrackingDeviceSource::Pointer m_ReferenceTrackingDeviceSource;
   mitk::NavigationDataRecorderDeprecated::Pointer m_ReferenceLoggingFilterXML;
   mitk::NavigationDataRecorderDeprecated::Pointer m_ReferenceLoggingFilterCSV;
 
   //members for file name list
   std::vector<std::string> m_FilenameVector;
   int m_NextFile;
 
   //help methods
   mitk::NavigationToolStorage::Pointer ReadStorage(std::string file);
   void MessageBox(std::string s);
   void DisableAllButtons();
   void EnableAllButtons();
   void FinishMeasurement();
   void StartLoggingAdditionalCSVFile(std::string filePostfix);
   void LogAdditionalCSVFile();
   void StopLoggingAdditionalCSVFile();
 
   //timer
   QTimer* m_Timer;
 
   //memebers for reference checking
   std::vector<mitk::Point3D> m_ReferenceStartPositions;
   bool m_referenceValid;
 
   //logging members
   int m_loggedFrames;
   bool m_logging;
   std::fstream m_logFileCSV;
 
   //event filter for key presses
   bool eventFilter(QObject *obj, QEvent *ev) override;
 
   //results members
   mitk::PointSet::Pointer m_MeanPoints;
   std::vector<double> m_RMSValues;
   mitk::NavigationDataEvaluationFilter::Pointer m_EvaluationFilter;
 
   bool m_tracking;
 };
 
 #endif // _QMITKIGTTRACKINGSEMIAUTOMATICMEASUREMENTVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUltrasoundCalibration.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUltrasoundCalibration.h
index d351794e7d..63f779b670 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUltrasoundCalibration.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUltrasoundCalibration.h
@@ -1,384 +1,380 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkUltrasoundCalibration_h
 #define QmitkUltrasoundCalibration_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 // MITK
 #include <mitkIGTLClient.h>
 #include <mitkNavigationDataToIGTLMessageFilter.h>
 #include <mitkNeedleProjectionFilter.h>
 #include <mitkPointSet.h>
 #include <mitkPointSetDifferenceStatisticsCalculator.h>
 #include <mitkUSCombinedModality.h>
 
 // Microservices
 #include "ui_QmitkUltrasoundCalibrationControls.h"
 
 #include <vtkLandmarkTransform.h>
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 
 #include <ctkServiceEvent.h>
 
 /*!
   \brief QmitkUltrasoundCalibration
 
   \warning  This view provides a simple calibration process.
 
-  \sa QmitkFunctionality
   \ingroup ${plugin_target}_internal
   */
 class QmitkUltrasoundCalibration : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
   QmitkUltrasoundCalibration();
   ~QmitkUltrasoundCalibration() override;
 
   static const std::string VIEW_ID;
 
   void CreateQtPartControl(QWidget *parent) override;
 
   void OnUSDepthChanged(const std::string &, const std::string &);
 
 protected slots:
 
   /**
    * \brief Triggered, whenever the user switches Tabs
    *
    */
   void OnTabSwitch(int index);
 
   /**
    * \brief Triggered, when the user has clicked "select Devices".
    *
    */
   void OnDeviceSelected();
   void OnDeviceDeselected();
 
   /**
    * \brief Triggered, when the user clicks "Add Point"
    *
    */
   void OnAddCalibPoint();
 
   /**
    * \brief Triggered, when the user clicks "Calibrate"
    *
    */
   void OnCalibration();
 
   /**
    * \brief Triggered, when the user clicks "Add Target Points".
    *
    * Adds an image point and an tracking point to their respective evaluation pointsets
    */
   void OnAddEvalTargetPoint();
 
   /**
    * \brief Triggered, when the user clicks "Add Point".
    *
    * Adds a projected point to the projected point evaluation set.
    */
   void OnAddEvalProjectedPoint();
 
   /**
    * \brief Triggered when the user clicks "Save Results" in the Evaluation tab.
    */
   void OnSaveEvaluation();
 
   /**
    * \brief Triggered when the user clicks "Save Calibration" in the Calibration tab.
    */
   void OnSaveCalibration();
 
   /**
    * \brief Triggered when the user clicks "Run Next Round". Also used as a reset mechanism.
    */
   void OnReset();
 
   /**
    * \brief Triggered in regular intervals by a timer, when live view is enabled.
    *
    */
   void Update();
 
   /**
    * \brief Freezes or unfreezes the image.
    */
   void SwitchFreeze();
 
   /**
    *
    */
   void OnStartCalibrationProcess();
 
   /**
    *\brief Method to use the PLUS-Toolkoit for Calibration of EchoTrack
    */
   void OnStartPlusCalibration();
 
   void OnStopPlusCalibration();
 
   /**
    *\ brief Starts the Streaming of USImage and Navigation Data when PLUS is connected
    */
   void OnStartStreaming();
 
   void OnNewConnection();
 
   /**
   \*brief Get the Calibration from the PLUS-Toolkit once Calibration with fCal is done
   */
   void OnGetPlusCalibration();
 
   /**
   \*brief Convert the recieved igtl::Matrix into an mitk::AffineTransform3D which can be used to calibrate the
   CombinedModality
   */
   void ProcessPlusCalibration(igtl::Matrix4x4 &imageToTracker);
 
   void OnStreamingTimerTimeout();
 
   /**
    *
    */
   void OnStopCalibrationProcess();
 
   void OnAddCurrentTipPositionToReferencePoints();
 
   void OnStartVerification();
 
   void OnAddCurrentTipPositionForVerification();
 
   void OnDeviceServiceEvent(const ctkServiceEvent event);
 
   void OnFreezeClicked();
 
   void OnAddSpacingPoint();
 
   void OnCalculateSpacing();
 
   /*
    * \brief load the configuration of the phantom fiducials which have to be saved as points in the sensor coordinate
    * system of the tracking sensor attached to the phantom
    */
   void OnLoadPhantomConfiguration();
   /*
    * \brief match the annotation pointset with the geometry of the phantom configuration
    */
   void OnMatchAnnotationToPhantomConfiguration();
   /*
    * \brief move the annotation pointset up
    */
   void OnMovePhantomAnnotationsUp();
   /*
    * \brief move the annotation pointset down
    */
   void OnMovePhantomAnnotationsDown();
   /*
    * \brief move the annotation pointset left
    */
   void OnMovePhantomAnnotationsLeft();
   /*
    * \brief move the annotation pointset right
    */
   void OnMovePhantomAnnotationsRight();
   /*
    * \brief rotate the annotation pointset right
    */
   void OnRotatePhantomAnnotationsRight();
   /*
    * \brief rotate the annotation pointset left
    */
   void OnRotatePhantomAnnotationsLeft();
 
   /*
    * \brief add a calibration point to be used for phantom based calibration
    */
   void OnPhantomCalibPointsChanged();
   /*
    * \brief perform phantom based calibration
    */
   void OnPhantomBasedCalibration();
 
 signals:
   /**
    * \brief used for thread seperation, the worker thread must not call OnNewConnection directly.
    * QT signals are thread safe and separate the threads
    */
   void NewConnectionSignal();
 
 protected:
   void SetFocus() override;
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer source, const QList<mitk::DataNode::Pointer> &nodes) override;
 
   void UpdatePhantomAnnotationPointVisualization(int index = -1);
   /*! \brief translate the annotated image feature m_CalibPoints image by the specified translation vector
   */
   void TranslatePhantomAnnotations(double tx, double ty, double tz);
   /*! \brief rotate the annotated image feature m_CalibPoints image by the specified angle
    */
   void RotatePhantomAnnotations(double angle);
 
   Ui::QmitkUltrasoundCalibrationControls m_Controls;
 
   /**
    * \brief Internal function that activates display of the needle path.
    */
   void ShowNeedlePath();
 
   /**
    * \brief Clears all member attributes which are holding intermediate results for the calibration.
    */
   void ClearTemporaryMembers();
 
   void OnPlusConnected();
 
   /**
    * \brief The combined modality used for imaging and tracking.
    */
   mitk::AbstractUltrasoundTrackerDevice::Pointer m_CombinedModality;
 
   /**
    * \brief NavigationDataSource used for tracking data.
    * This will be gotten by the combined modality.
    */
   mitk::NavigationDataSource::Pointer m_Tracker;
 
   QTimer *m_Timer;
 
   mitk::DataNode::Pointer m_Node;
   mitk::DataNode::Pointer m_CalibNode;
   mitk::DataNode::Pointer m_WorldNode;
 
   // IGTL Servers and Devices needed for the communication with PLUS
   mitk::IGTLServer::Pointer m_USServer;
   mitk::IGTLMessageProvider::Pointer m_USMessageProvider;
   mitk::ImageToIGTLMessageFilter::Pointer m_USImageToIGTLMessageFilter;
 
   mitk::IGTLServer::Pointer m_TrackingServer;
   mitk::IGTLMessageProvider::Pointer m_TrackingMessageProvider;
   mitk::NavigationDataToIGTLMessageFilter::Pointer m_TrackingToIGTLMessageFilter;
 
   mitk::IGTLClient::Pointer m_TransformClient;
   mitk::IGTLDeviceSource::Pointer m_TransformDeviceSource;
 
   QTimer *m_StreamingTimer;
 
   unsigned long m_NewConnectionObserverTag;
 
   /**
    * \brief The current Ultrasound Image.
    */
   mitk::Image::Pointer m_Image;
   /**
    * \brief Current point when the image was last frozen.
    */
   mitk::Point3D m_FreezePoint;
 
   /**
    * \brief Pointset containing all tool points.
    */
   mitk::PointSet::Pointer m_CalibPointsImage;
   /**
    * \brief Pointset containing corresponding points on the image.
    */
   mitk::PointSet::Pointer m_CalibPointsTool;
   mitk::PointSet::Pointer
     m_PhantomConfigurationPointSet; ///< pointset holding the feature position of the phantom in tool coordinates
   /**
    * \brief Pointset containing Projected Points (aka "where we thought the needle was gonna land")
    */
   mitk::PointSet::Pointer m_EvalPointsProjected;
   /**
    * \brief Pointset containing the evaluated points on the image.
    */
   mitk::PointSet::Pointer m_EvalPointsImage;
   /**
    * \brief Pointset containing tracked evaluation points.
    */
   mitk::PointSet::Pointer m_EvalPointsTool;
 
   /**
    * \brief Pointset containing tracked evaluation points.
    */
   mitk::PointSet::Pointer m_VerificationReferencePoints;
   mitk::DataNode::Pointer m_VerificationReferencePointsDataNode;
 
   int m_currentPoint;
   std::vector<mitk::Point3D> m_allReferencePoints;
   std::vector<double> m_allErrors;
 
   /**
    * \brief Creates a Pointset that projects the needle's path
    */
   mitk::NeedleProjectionFilter::Pointer m_NeedleProjectionFilter;
   /**
    * \brief Total number of calibration points set.
    */
   int m_CalibPointsCount;
 
   QString m_CurrentDepth;
 
   /**
    * \brief StatisticsRegarding Projection Accuracy.
    * (Compares m_EvalPointsProjected to m_EvalPointsImage)
    */
   mitk::PointSetDifferenceStatisticsCalculator::Pointer m_ProjectionStatistics;
   /**
    * \brief StatisticsRegarding Evaluation Accuracy.
    * (Compares m_EvalPointsTool to m_EvalPointsImage)
    */
   mitk::PointSetDifferenceStatisticsCalculator::Pointer m_EvaluationStatistics;
   /**
    * \brief StatisticsRegarding Calibration Accuracy.
    * (Compares m_CalibPointsTool to a transformed copy of m_CalibPointsImage).
    */
   mitk::PointSetDifferenceStatisticsCalculator::Pointer m_CalibrationStatistics;
 
   /**
    * \brief Result of the Calibration.
    */
   mitk::AffineTransform3D::Pointer m_Transformation;
 
   /**
    * This method is copied from PointSetModifier which is part of MBI. It should be replaced
    * by external method call as soon as this functionality will be available in MITK.
    */
   vtkSmartPointer<vtkPolyData> ConvertPointSetToVtkPolyData(mitk::PointSet::Pointer PointSet);
 
   double ComputeFRE(mitk::PointSet::Pointer imageFiducials,
                     mitk::PointSet::Pointer realWorldFiducials,
                     vtkSmartPointer<vtkLandmarkTransform> transform = nullptr);
 
   void ApplyTransformToPointSet(mitk::PointSet::Pointer pointSet, vtkSmartPointer<vtkAbstractTransform> transform);
 
   mitk::PointSet::Pointer m_SpacingPoints;
   mitk::DataNode::Pointer m_SpacingNode;
   int m_SpacingPointsCount;
 
 private:
   mitk::MessageDelegate2<QmitkUltrasoundCalibration, const std::string &, const std::string &> m_USDeviceChanged;
 };
 
 #endif // UltrasoundCalibration_h
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/USNavigation.h b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/USNavigation.h
index 807cca9712..681bd8a093 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/USNavigation.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/USNavigation.h
@@ -1,171 +1,168 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef USNavigation_h
 #define USNavigation_h
 
 // Blueberry, QMITK
 #include <berryISelectionListener.h>
 #include <QmitkAbstractView.h>
 #include "ui_USNavigationControls.h"
 
 // QT
 #include <QTimer>
 #include <QProgressBar>
 
 // MITK
 #include <mitkNavigationDataSource.h>
 #include <mitkNavigationToolStorage.h>
 #include <mitkUSCombinedModality.h>
 #include <mitkNodeDisplacementFilter.h>
 #include <mitkNeedleProjectionFilter.h>
 #include <mitkNavigationDataSmoothingFilter.h>
 #include <mitkCameraVisualization.h>
 
 /*!
   \brief USNavigation
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
-  \sa QmitkFunctionality
   \ingroup ${plugin_target}_internal
 */
 class USNavigation : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     USNavigation();
     virtual void CreateQtPartControl(QWidget *parent);
 
   protected slots:
 
     /**
     * \brief Triggered, when the user selects a device from either the list of USDevices or Tracking Devices
     */
     //void OnClickDevices();
     void OnDeviceSelected();
     void OnDeviceDeselected();
 
     /**
     * \brief Triggered, when the user has clicked "select Devices".
     */
     void OnSelectDevices();
 
     /**
     * \brief Triggered, when the user has clicked "Load Calibration".
     */
     //void OnLoadCalibration();
 
     /**
     * \brief
     */
     void OnStartIntervention();
 
     /**
     * \brief
     */
     void OnFreeze();
 
     /**
     * \brief
     */
     void OnReset();
 
     /**
     * \brief
     */
     void OnNeedleViewToggle();
 
     void OnZoneAdded();
 
     /**
     * \brief
     */
     void Update();
 
     void UpdateMeters();
 
   protected:
 
     mitk::NavigationToolStorage::Pointer m_ToolStorage;
     std::vector<mitk::DataNode::Pointer> m_Zones;
     mitk::DataNode::Pointer m_USStream;
 
     bool m_Freeze;
 
     QString m_RangeMeterStyle;
 
     /**
     * \brief The CombinedModality used for imaging.
     */
     mitk::USCombinedModality::Pointer m_USDevice;
 
     /**
     * \brief Temporary saving point for loaded calibration data.
     */
     std::string m_LoadedCalibration;
 
     /**
     * \brief NavigationDataSource used for tracking data.
     */
     mitk::NavigationDataSource::Pointer m_Tracker;
 
     mitk::NodeDisplacementFilter::Pointer m_ZoneFilter;
 
     mitk::NavigationDataSmoothingFilter::Pointer m_SmoothingFilter;
 
     mitk::CameraVisualization::Pointer m_CameraVis;
 
     /**
     * \brief Creates a Pointset that projects the needle's path
     */
     mitk::NeedleProjectionFilter::Pointer m_NeedleProjectionFilter;
 
     /**
     * \brief Colors the given node according to the color selected in the "Edit Zone" section, names it correctly and adjusts it's size.
     */
     void FormatZoneNode(mitk::DataNode::Pointer node, mitk::Point3D center);
 
     /**
     * \brief Sets up the RangeMeter Section of the Navigation by creating and initializing all necessary Progress Bars.
     */
     void SetupProximityView();
 
     QProgressBar* CreateRangeMeter(int i);
     void ResetRangeMeters();
 
     std::vector< QProgressBar* > m_RangeMeters;
 
     virtual void SetFocus();
 
     QTimer *m_Timer;
     QTimer *m_RangeMeterTimer;
 
     bool m_UpdateImage;
 
     bool m_IsNeedleViewActive;
 
     static const int MAXRANGE = 60;
     static const int WARNRANGE = 25;
 
     Ui::USNavigationControls m_Controls;
 
     bool m_ImageAlreadySetToNode;
 };
 
 #endif // USNavigation_h
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkPlugin.h b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkPlugin.h
index d32c533518..f4f94bf978 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkPlugin.h
+++ b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkPlugin.h
@@ -1,104 +1,101 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef OpenIGTLinkPlugin_h
 #define OpenIGTLinkPlugin_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_OpenIGTLinkPluginControls.h"
 
 #include "qtimer.h"
 
 //OIGTL
 #include "mitkIGTLClient.h"
 #include "mitkIGTL2DImageDeviceSource.h"
 #include "mitkIGTL3DImageDeviceSource.h"
 #include "mitkIGTLTrackingDataDeviceSource.h"
 
 //mitk
 #include "mitkNavigationDataObjectVisualizationFilter.h"
 #include "mitkIGTLMessageToNavigationDataFilter.h"
 #include "mitkIGTLMessageToUSImageFilter.h"
 #include <mitkSurface.h>
 #include <mitkDataNode.h>
 
 //vtk
 #include <vtkSphereSource.h>
 
 /**
   \brief OpenIGTLinkPlugin
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \sa QmitkAbstractView
   \ingroup ${plugin_target}_internal
   */
 class OpenIGTLinkPlugin : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   protected slots:
 
   void ConnectButtonClicked();
 
   void ReceivingButtonClicked();
 
   void UpdatePipeline();
 
 protected:
 
   enum State{
     IDLE, CONNECTED, RECEIVING
   };
 
   void CreateQtPartControl(QWidget *parent) override;
 
   void SetFocus() override;
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
     const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::OpenIGTLinkPluginControls m_Controls;
 
   mitk::IGTL2DImageDeviceSource::Pointer m_IGTL2DImageDeviceSource;
   mitk::IGTL3DImageDeviceSource::Pointer m_IGTL3DImageDeviceSource;
   mitk::IGTLTrackingDataDeviceSource::Pointer m_IGTLTransformDeviceSource;
 
   mitk::IGTLClient::Pointer m_IGTLClient;
 
   QTimer m_Timer;
 
   mitk::IGTLMessageToNavigationDataFilter::Pointer m_IGTLMessageToNavigationDataFilter;
   mitk::NavigationDataObjectVisualizationFilter::Pointer m_NavigationDataObjectVisualizationFilter;
   mitk::IGTLMessageToUSImageFilter::Pointer m_ImageFilter3D;
   mitk::IGTLMessageToUSImageFilter::Pointer m_ImageFilter2D;
 
   mitk::DataNode::Pointer m_Image2dNode;
 
 private:
 
   void StateChanged(State newState);
 
   State m_State;
 };
 
 #endif // OpenIGTLinkPlugin_h
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTFiducialRegistration.h b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTFiducialRegistration.h
index e04e4e4294..214c835c6c 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTFiducialRegistration.h
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkIGTFiducialRegistration.h
@@ -1,68 +1,65 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkIGTFiducialRegistration_h
 #define QmitkIGTFiducialRegistration_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_QmitkIGTFiducialRegistrationControls.h"
 
 
 #include <ctkServiceEvent.h>
 
 /*!
 \brief QmitkIGTFiducialRegistration
 
-\sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class QmitkIGTFiducialRegistration : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
   public:
 
     void SetFocus() override;
 
     static const std::string VIEW_ID;
 
     void CreateQtPartControl(QWidget *parent) override;
 
     QmitkIGTFiducialRegistration();
     ~QmitkIGTFiducialRegistration() override;
 
   public slots:
 
 
   protected slots:
 
   void PointerSelectionChanged();
   void ImageSelectionChanged();
 
 
   protected:
 
     void InitializeRegistration();
 
     Ui::IGTFiducialRegistrationControls m_Controls;
 
     mitk::NavigationData::Pointer m_TrackingPointer;
 
 
 };
 
 #endif // IGTFiducialRegistration_h
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropperView.cpp b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropperView.cpp
index aca4f168a7..9eab83e044 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropperView.cpp
+++ b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropperView.cpp
@@ -1,510 +1,513 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkImageCropperView.h"
 
 #include <mitkBoundingShapeCropper.h>
 #include <mitkDisplayInteractor.h>
 #include <mitkImageStatisticsHolder.h>
 #include <mitkInteractionConst.h>
 #include <mitkITKImageImport.h>
 #include <mitkLabelSetImage.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateFunction.h>
 #include <mitkRenderingManager.h>
 
 #include <usModuleRegistry.h>
 
 #include <QMessageBox>
 
 const std::string QmitkImageCropperView::VIEW_ID = "org.mitk.views.qmitkimagecropper";
 
 QmitkImageCropperView::QmitkImageCropperView(QObject *)
   : m_ParentWidget(nullptr)
   , m_BoundingShapeInteractor(nullptr)
   , m_CropOutsideValue(0)
 {
   CreateBoundingShapeInteractor(false);
 }
 
 QmitkImageCropperView::~QmitkImageCropperView()
 {
   //disable interactor
   if (m_BoundingShapeInteractor != nullptr)
   {
     m_BoundingShapeInteractor->SetDataNode(nullptr);
     m_BoundingShapeInteractor->EnableInteraction(false);
   }
 }
 
 void QmitkImageCropperView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
 
   m_Controls.imageSelectionWidget->SetDataStorage(GetDataStorage());
-  m_Controls.imageSelectionWidget->SetNodePredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
+  m_Controls.imageSelectionWidget->SetNodePredicate(
+    mitk::NodePredicateAnd::New(mitk::TNodePredicateDataType<mitk::Image>::New(),
+                                mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))));
   m_Controls.imageSelectionWidget->SetSelectionIsOptional(true);
   m_Controls.imageSelectionWidget->SetAutoSelectNewNodes(true);
   m_Controls.imageSelectionWidget->SetEmptyInfo(QString("Please select an image node"));
   m_Controls.imageSelectionWidget->SetPopUpTitel(QString("Select image node"));
 
   connect(m_Controls.imageSelectionWidget, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkImageCropperView::OnImageSelectionChanged);
 
   m_Controls.boundingBoxSelectionWidget->SetDataStorage(GetDataStorage());
   m_Controls.boundingBoxSelectionWidget->SetNodePredicate(mitk::NodePredicateAnd::New(
     mitk::TNodePredicateDataType<mitk::GeometryData>::New(),
     mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))));
   m_Controls.boundingBoxSelectionWidget->SetSelectionIsOptional(true);
   m_Controls.boundingBoxSelectionWidget->SetAutoSelectNewNodes(true);
   m_Controls.boundingBoxSelectionWidget->SetEmptyInfo(QString("Please select a bounding box"));
   m_Controls.boundingBoxSelectionWidget->SetPopUpTitel(QString("Select bounding box node"));
 
   connect(m_Controls.boundingBoxSelectionWidget, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkImageCropperView::OnBoundingBoxSelectionChanged);
 
   connect(m_Controls.buttonCreateNewBoundingBox, SIGNAL(clicked()), this, SLOT(OnCreateNewBoundingBox()));
   connect(m_Controls.buttonCropping, SIGNAL(clicked()), this, SLOT(OnCropping()));
   connect(m_Controls.buttonMasking, SIGNAL(clicked()), this, SLOT(OnMasking()));
   auto lambda = [this]()
   {
     m_Controls.groupImageSettings->setVisible(!m_Controls.groupImageSettings->isVisible());
   };
 
   connect(m_Controls.buttonAdvancedSettings, &ctkExpandButton::clicked, this, lambda);
 
   connect(m_Controls.spinBoxOutsidePixelValue, SIGNAL(valueChanged(int)), this, SLOT(OnSliderValueChanged(int)));
 
   SetDefaultGUI();
 
   m_ParentWidget = parent;
 
   this->OnImageSelectionChanged(m_Controls.imageSelectionWidget->GetSelectedNodes());
   this->OnBoundingBoxSelectionChanged(m_Controls.boundingBoxSelectionWidget->GetSelectedNodes());
 }
 
 void QmitkImageCropperView::OnImageSelectionChanged(QList<mitk::DataNode::Pointer>)
 {
   bool rotationEnabled = false;
+  m_Controls.labelWarningRotation->setVisible(false);
+
   auto imageNode = m_Controls.imageSelectionWidget->GetSelectedNode();
   if (imageNode.IsNull())
   {
     SetDefaultGUI();
     return;
   }
 
   auto image = dynamic_cast<mitk::Image*>(imageNode->GetData());
   if (nullptr != image)
   {
     if (image->GetDimension() < 3)
     {
       QMessageBox::warning(nullptr,
         tr("Invalid image selected"),
         tr("ImageCropper only works with 3 or more dimensions."),
         QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
       SetDefaultGUI();
       return;
     }
 
     m_ParentWidget->setEnabled(true);
     m_Controls.buttonCreateNewBoundingBox->setEnabled(true);
 
     vtkSmartPointer<vtkMatrix4x4> imageMat = image->GetGeometry()->GetVtkMatrix();
     // check whether the image geometry is rotated; if so, no pixel aligned cropping or masking can be performed
     if ((imageMat->GetElement(1, 0) == 0.0) && (imageMat->GetElement(0, 1) == 0.0) &&
       (imageMat->GetElement(1, 2) == 0.0) && (imageMat->GetElement(2, 1) == 0.0) &&
       (imageMat->GetElement(2, 0) == 0.0) && (imageMat->GetElement(0, 2) == 0.0))
     {
       rotationEnabled = false;
       m_Controls.labelWarningRotation->setVisible(false);
     }
     else
     {
       rotationEnabled = true;
       m_Controls.labelWarningRotation->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
       m_Controls.labelWarningRotation->setVisible(true);
     }
 
     this->CreateBoundingShapeInteractor(rotationEnabled);
 
     if (itk::IOPixelEnum::SCALAR == image->GetPixelType().GetPixelType())
     {
       // Might be changed with the upcoming new image statistics plugin
       //(recomputation might be very expensive for large images ;) )
       auto statistics = image->GetStatistics();
       auto minPixelValue = statistics->GetScalarValueMin();
       auto maxPixelValue = statistics->GetScalarValueMax();
 
       if (minPixelValue < std::numeric_limits<int>::min())
       {
         minPixelValue = std::numeric_limits<int>::min();
       }
       if (maxPixelValue > std::numeric_limits<int>::max())
       {
         maxPixelValue = std::numeric_limits<int>::max();
       }
 
       m_Controls.spinBoxOutsidePixelValue->setEnabled(true);
       m_Controls.spinBoxOutsidePixelValue->setMaximum(static_cast<int>(maxPixelValue));
       m_Controls.spinBoxOutsidePixelValue->setMinimum(static_cast<int>(minPixelValue));
       m_Controls.spinBoxOutsidePixelValue->setValue(static_cast<int>(minPixelValue));
     }
     else
     {
       m_Controls.spinBoxOutsidePixelValue->setEnabled(false);
     }
 
     unsigned int dim = image->GetDimension();
     if (dim < 2 || dim > 4)
     {
       m_ParentWidget->setEnabled(false);
     }
 
     if (m_Controls.boundingBoxSelectionWidget->GetSelectedNode().IsNotNull())
     {
       m_Controls.buttonCropping->setEnabled(true);
       m_Controls.buttonMasking->setEnabled(true);
       m_Controls.buttonAdvancedSettings->setEnabled(true);
       m_Controls.groupImageSettings->setEnabled(true);
     }
   }
 }
 
 void QmitkImageCropperView::OnBoundingBoxSelectionChanged(QList<mitk::DataNode::Pointer>)
 {
   auto boundingBoxNode = m_Controls.boundingBoxSelectionWidget->GetSelectedNode();
   if (boundingBoxNode.IsNull())
   {
     SetDefaultGUI();
 
     m_BoundingShapeInteractor->EnableInteraction(false);
     m_BoundingShapeInteractor->SetDataNode(nullptr);
 
     if (m_Controls.imageSelectionWidget->GetSelectedNode().IsNotNull())
     {
       m_Controls.buttonCreateNewBoundingBox->setEnabled(true);
     }
 
     return;
   }
 
   auto boundingBox = dynamic_cast<mitk::GeometryData*>(boundingBoxNode->GetData());
   if (nullptr != boundingBox)
   {
     // node newly selected
     boundingBoxNode->SetVisibility(true);
 
     m_BoundingShapeInteractor->EnableInteraction(true);
     m_BoundingShapeInteractor->SetDataNode(boundingBoxNode);
 
     mitk::RenderingManager::GetInstance()->InitializeViews();
 
     if (m_Controls.imageSelectionWidget->GetSelectedNode().IsNotNull())
     {
       m_Controls.buttonCropping->setEnabled(true);
       m_Controls.buttonMasking->setEnabled(true);
       m_Controls.buttonAdvancedSettings->setEnabled(true);
       m_Controls.groupImageSettings->setEnabled(true);
     }
   }
 }
 
 void QmitkImageCropperView::OnCreateNewBoundingBox()
 {
   auto imageNode = m_Controls.imageSelectionWidget->GetSelectedNode();
   if (imageNode.IsNull())
   {
     return;
   }
   if (nullptr == imageNode->GetData())
   {
     return;
   }
 
   QString name = QString::fromStdString(imageNode->GetName() + " Bounding Shape");
 
   auto boundingShape = this->GetDataStorage()->GetNode(mitk::NodePredicateFunction::New([&name](const mitk::DataNode *node)
   {
     return 0 == node->GetName().compare(name.toStdString());
   }));
 
   if (nullptr != boundingShape)
   {
     name = this->AdaptBoundingObjectName(name);
   }
 
   // get current timestep to support 3d+t images
   auto renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
   const auto timePoint = renderWindowPart->GetSelectedTimePoint();
   const auto imageGeometry = imageNode->GetData()->GetTimeGeometry()->GetGeometryForTimePoint(timePoint);
 
   auto boundingBox = mitk::GeometryData::New();
   boundingBox->SetGeometry(static_cast<mitk::Geometry3D*>(this->InitializeWithImageGeometry(imageGeometry)));
   auto boundingBoxNode = mitk::DataNode::New();
   boundingBoxNode->SetData(boundingBox);
   boundingBoxNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
   boundingBoxNode->SetProperty("color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
   boundingBoxNode->SetProperty("opacity", mitk::FloatProperty::New(0.6));
   boundingBoxNode->SetProperty("layer", mitk::IntProperty::New(99));
   boundingBoxNode->AddProperty("handle size factor", mitk::DoubleProperty::New(1.0 / 40.0));
   boundingBoxNode->SetBoolProperty("pickable", true);
 
   if (!this->GetDataStorage()->Exists(boundingBoxNode))
   {
     GetDataStorage()->Add(boundingBoxNode, imageNode);
   }
 
   m_Controls.boundingBoxSelectionWidget->SetCurrentSelectedNode(boundingBoxNode);
 }
 
 void QmitkImageCropperView::OnCropping()
 {
   this->ProcessImage(false);
 }
 
 void QmitkImageCropperView::OnMasking()
 {
   this->ProcessImage(true);
 }
 
 void QmitkImageCropperView::OnSliderValueChanged(int slidervalue)
 {
   m_CropOutsideValue = slidervalue;
 }
 
 void QmitkImageCropperView::CreateBoundingShapeInteractor(bool rotationEnabled)
 {
   if (m_BoundingShapeInteractor.IsNull())
   {
     m_BoundingShapeInteractor = mitk::BoundingShapeInteractor::New();
     m_BoundingShapeInteractor->LoadStateMachine("BoundingShapeInteraction.xml", us::ModuleRegistry::GetModule("MitkBoundingShape"));
     m_BoundingShapeInteractor->SetEventConfig("BoundingShapeMouseConfig.xml", us::ModuleRegistry::GetModule("MitkBoundingShape"));
   }
   m_BoundingShapeInteractor->SetRotationEnabled(rotationEnabled);
 }
 
 mitk::Geometry3D::Pointer QmitkImageCropperView::InitializeWithImageGeometry(const mitk::BaseGeometry* geometry) const
 {
   // convert a BaseGeometry into a Geometry3D (otherwise IO is not working properly)
   if (geometry == nullptr)
     mitkThrow() << "Geometry is not valid.";
 
   auto boundingGeometry = mitk::Geometry3D::New();
   boundingGeometry->SetBounds(geometry->GetBounds());
   boundingGeometry->SetImageGeometry(geometry->GetImageGeometry());
   boundingGeometry->SetOrigin(geometry->GetOrigin());
   boundingGeometry->SetSpacing(geometry->GetSpacing());
   boundingGeometry->SetIndexToWorldTransform(geometry->GetIndexToWorldTransform()->Clone());
   boundingGeometry->Modified();
   return boundingGeometry;
 }
 
 void QmitkImageCropperView::ProcessImage(bool mask)
 {
   auto renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
   const auto timePoint = renderWindowPart->GetSelectedTimePoint();
 
   auto imageNode = m_Controls.imageSelectionWidget->GetSelectedNode();
   if (imageNode.IsNull())
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
     return;
   }
 
   auto boundingBoxNode = m_Controls.boundingBoxSelectionWidget->GetSelectedNode();
   if (boundingBoxNode.IsNull())
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select a cropping object before starting image processing.");
     return;
   }
 
   if (!imageNode->GetData()->GetTimeGeometry()->IsValidTimePoint(timePoint))
   {
     QMessageBox::information(nullptr, "Warning", "Please select a time point that is within the time bounds of the selected image.");
     return;
   }
   const auto timeStep = imageNode->GetData()->GetTimeGeometry()->TimePointToTimeStep(timePoint);
 
   auto image = dynamic_cast<mitk::Image*>(imageNode->GetData());
   auto boundingBox = dynamic_cast<mitk::GeometryData*>(boundingBoxNode->GetData());
   if (nullptr != image && nullptr != boundingBox)
   {
     // Check if initial node name is already in box name
     std::string imagePrefix = "";
     if (boundingBoxNode->GetName().find(imageNode->GetName()) != 0)
     {
       imagePrefix = imageNode->GetName() + "_";
     }
 
     QString imageName;
     if (mask)
     {
       imageName = QString::fromStdString(imagePrefix + boundingBoxNode->GetName() + "_masked");
     }
     else
     {
       imageName = QString::fromStdString(imagePrefix + boundingBoxNode->GetName() + "_cropped");
     }
 
     if (m_Controls.checkBoxCropTimeStepOnly->isChecked())
     {
       imageName = imageName + "_T" + QString::number(timeStep);
     }
 
     // image and bounding shape ok, set as input
     auto croppedImageNode = mitk::DataNode::New();
     auto cutter = mitk::BoundingShapeCropper::New();
     cutter->SetGeometry(boundingBox);
 
     // adjustable in advanced settings
     cutter->SetUseWholeInputRegion(mask); //either mask (mask=true) or crop (mask=false)
     cutter->SetOutsideValue(m_CropOutsideValue);
     cutter->SetUseCropTimeStepOnly(m_Controls.checkBoxCropTimeStepOnly->isChecked());
     cutter->SetCurrentTimeStep(timeStep);
 
     // TODO: Add support for MultiLayer (right now only Mulitlabel support)
     auto labelsetImageInput = dynamic_cast<mitk::LabelSetImage*>(image);
     if (nullptr != labelsetImageInput)
     {
       cutter->SetInput(labelsetImageInput);
       // do the actual cutting
       try
       {
         cutter->Update();
       }
       catch (const itk::ExceptionObject& e)
       {
         std::string message = std::string("The Cropping filter could not process because of: \n ") + e.GetDescription();
         QMessageBox::warning(nullptr, tr("Cropping not possible!"), tr(message.c_str()),
           QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
         return;
       }
 
       auto labelSetImage = mitk::LabelSetImage::New();
       labelSetImage->InitializeByLabeledImage(cutter->GetOutput());
 
       for (unsigned int i = 0; i < labelsetImageInput->GetNumberOfLayers(); i++)
       {
         labelSetImage->AddLabelSetToLayer(i, labelsetImageInput->GetLabelSet(i));
       }
 
       croppedImageNode->SetData(labelSetImage);
       croppedImageNode->SetProperty("name", mitk::StringProperty::New(imageName.toStdString()));
 
       //add cropping result to the current data storage as child node to the image node
       if (!m_Controls.checkOverwriteImage->isChecked())
       {
         if (!this->GetDataStorage()->Exists(croppedImageNode))
         {
           this->GetDataStorage()->Add(croppedImageNode, imageNode);
         }
       }
       else // original image will be overwritten by the result image and the bounding box of the result is adjusted
       {
         imageNode->SetData(labelSetImage);
         imageNode->Modified();
         // Adjust coordinate system by doing a reinit on
         auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
         tempDataStorage->InsertElement(0, imageNode);
 
         // initialize the views to the bounding geometry
         auto bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
         mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
       }
     }
     else
     {
       cutter->SetInput(image);
       // do the actual cutting
       try
       {
         cutter->Update();
       }
       catch (const itk::ExceptionObject& e)
       {
         std::string message = std::string("The Cropping filter could not process because of: \n ") + e.GetDescription();
         QMessageBox::warning(nullptr, tr("Cropping not possible!"), tr(message.c_str()),
           QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
         return;
       }
 
       //add cropping result to the current data storage as child node to the image node
       if (!m_Controls.checkOverwriteImage->isChecked())
       {
         croppedImageNode->SetData(cutter->GetOutput());
         croppedImageNode->SetProperty("name", mitk::StringProperty::New(imageName.toStdString()));
         croppedImageNode->SetProperty("color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
 
         mitk::LevelWindow levelWindow;
         imageNode->GetLevelWindow(levelWindow);
         croppedImageNode->SetLevelWindow(levelWindow);
 
         if (!this->GetDataStorage()->Exists(croppedImageNode))
         {
           this->GetDataStorage()->Add(croppedImageNode, imageNode);
           imageNode->SetVisibility(mask); // Give the user a visual clue that something happened when image was cropped
         }
       }
       else // original image will be overwritten by the result image and the bounding box of the result is adjusted
       {
         mitk::LevelWindow levelWindow;
         imageNode->GetLevelWindow(levelWindow);
         imageNode->SetData(cutter->GetOutput());
         imageNode->SetLevelWindow(levelWindow);
         // Adjust coordinate system by doing a reinit on
         auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
         tempDataStorage->InsertElement(0, imageNode);
 
         // initialize the views to the bounding geometry
         auto bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
         mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
       }
     }
   }
   else
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
   }
 }
 
 void QmitkImageCropperView::SetDefaultGUI()
 {
-  m_Controls.labelWarningRotation->setVisible(false);
   m_Controls.buttonCreateNewBoundingBox->setEnabled(false);
   m_Controls.buttonCropping->setEnabled(false);
   m_Controls.buttonMasking->setEnabled(false);
   m_Controls.buttonAdvancedSettings->setEnabled(false);
   m_Controls.groupImageSettings->setEnabled(false);
   m_Controls.groupImageSettings->setVisible(false);
   m_Controls.checkOverwriteImage->setChecked(false);
   m_Controls.checkBoxCropTimeStepOnly->setChecked(false);
 }
 
 QString QmitkImageCropperView::AdaptBoundingObjectName(const QString& name) const
 {
   unsigned int counter = 2;
   QString newName = QString("%1 %2").arg(name).arg(counter);
 
   while (nullptr != this->GetDataStorage()->GetNode(mitk::NodePredicateFunction::New([&newName](const mitk::DataNode *node)
   {
     return 0 == node->GetName().compare(newName.toStdString());
   })))
   {
     newName = QString("%1 %2").arg(name).arg(++counter);
   }
 
   return newName;
 }
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropperViewControls.ui b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropperViewControls.ui
index d7e2d78d35..6afea7fa3c 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropperViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropperViewControls.ui
@@ -1,311 +1,311 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkImageCropperViewControls</class>
  <widget class="QWidget" name="QmitkImageCropperViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>300</width>
     <height>600</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupBox">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="title">
      <string>Data Selection</string>
     </property>
     <layout class="QGridLayout" name="gridLayoutDataSelection">
 	 <item row="0" column="0">
       <widget class="QLabel" name="labelImage">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Image</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QmitkSingleNodeSelectionWidget" name="imageSelectionWidget" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>40</height>
         </size>
        </property>
       </widget>
      </item>
 	 <item row="1" column="0">
       <widget class="QLabel" name="labelBoundingBox">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Bounding Box</string>
        </property>
       </widget>
      </item>
 	 <item row="1" column="1">
       <widget class="QmitkSingleNodeSelectionWidget" name="boundingBoxSelectionWidget" native="true">
 	   <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>40</height>
         </size>
        </property>
       </widget>
 	  </item>
 	  <item row="1" column="2">
 	   <widget class="QPushButton" name="buttonCreateNewBoundingBox">
  	    <property name="sizePolicy">
          <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
 	    <property name="minimumSize">
          <size>
           <width>0</width>
           <height>40</height>
          </size>
         </property>
         <property name="text">
          <string>New</string>
         </property>
        </widget>
       </item>
 	 </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBoundingObject">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>90</height>
       </size>
      </property>
      <property name="title">
       <string>Processing</string>
      </property>
      <layout class="QGridLayout" name="gridLayoutProcessing">
       <item row="0" column="0">
        <widget class="QPushButton" name="buttonMasking">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="text">
          <string>Mask</string>
         </property>
        </widget>
       </item>
       <item row="" column="1">
        <widget class="QPushButton" name="buttonCropping">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="text">
          <string>Crop</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QLabel" name="labelWarningRotation">
      <property name="enabled">
       <bool>true</bool>
      </property>
      <property name="text">
-      <string>Image geometry is rotated, result won't be pixel-aligned. You can reinit your image to get a pixel-aligned result, though.</string>
+      <string>The selected image has a rotated geometry, result won't be pixel-aligned</string>
      </property>
      <property name="textFormat">
       <enum>Qt::PlainText</enum>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="ctkExpandButton" name="buttonAdvancedSettings">
      <property name="sizePolicy">
       <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>25</height>
       </size>
      </property>
      <property name="text">
       <string>Advanced settings</string>
      </property>
      <property name="checkable">
       <bool>false</bool>
      </property>
      <property name="autoRepeatInterval">
       <number>100</number>
      </property>
      <property name="toolButtonStyle">
       <enum>Qt::ToolButtonTextBesideIcon</enum>
      </property>
      <property name="autoRaise">
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupImageSettings">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>120</height>
       </size>
      </property>
      <property name="title">
       <string>Output image settings</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <layout class="QHBoxLayout" name="horizontalLayoutSettings">
         <item>
          <widget class="QLabel" name="labelOutsidePixelValue">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Outside pixel value (masking):</string>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QSpinBox" name="spinBoxOutsidePixelValue">
           <property name="enabled">
            <bool>false</bool>
           </property>
           <property name="sizePolicy">
            <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
          </widget>
         </item>
        </layout>
       </item>
       <item>
        <widget class="QCheckBox" name="checkOverwriteImage">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="text">
          <string>Overrride original image</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="checkBoxCropTimeStepOnly">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="text">
          <string>Only crop current timestep
 / cut off other timesteps</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QmitkSingleNodeSelectionWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkSingleNodeSelectionWidget.h</header>
   </customwidget>
   <customwidget>
    <class>ctkExpandButton</class>
    <extends>QToolButton</extends>
    <header>ctkExpandButton.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
index 9aa912fb4a..c22961b79f 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
@@ -1,612 +1,612 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkImageNavigatorView.h"
 
 #include <itkSpatialOrientationAdapter.h>
 
 #include <QmitkStepperAdapter.h>
 #include <QmitkRenderWindow.h>
 
 #include <mitkTimeGeometry.h>
 
 #include <berryConstants.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkStatusBar.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkNodePredicateProperty.h>
 
 #include <mitkCompositePixelValueToString.h>
 
 const std::string QmitkImageNavigatorView::VIEW_ID = "org.mitk.views.imagenavigator";
 
 QmitkImageNavigatorView::QmitkImageNavigatorView()
   : m_AxialStepper(nullptr)
   , m_SagittalStepper(nullptr)
-  , m_FrontalStepper(nullptr)
+  , m_CoronalStepper(nullptr)
   , m_TimeStepper(nullptr)
   , m_Parent(nullptr)
   , m_IRenderWindowPart(nullptr)
 {
 }
 
 QmitkImageNavigatorView::~QmitkImageNavigatorView()
 {
 }
 
 void QmitkImageNavigatorView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets
   m_Parent = parent;
   m_Controls.setupUi(parent);
 
   connect(m_Controls.m_XWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
   connect(m_Controls.m_YWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
   connect(m_Controls.m_ZWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
 
   m_Parent->setEnabled(false);
 
   mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
   this->RenderWindowPartActivated(renderPart);
 }
 
 void QmitkImageNavigatorView::SetFocus ()
 {
   m_Controls.m_XWorldCoordinateSpinBox->setFocus();
 }
 
 void QmitkImageNavigatorView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (this->m_IRenderWindowPart != renderWindowPart)
   {
     this->m_IRenderWindowPart = renderWindowPart;
     this->m_Parent->setEnabled(true);
 
     QmitkRenderWindow* renderWindow = renderWindowPart->GetQmitkRenderWindow("axial");
     if (renderWindow)
     {
       if (m_AxialStepper) m_AxialStepper->deleteLater();
       m_AxialStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorAxial,
                                                      renderWindow->GetSliceNavigationController()->GetSlice(),
                                                      "sliceNavigatorAxialFromSimpleExample");
       m_Controls.m_SliceNavigatorAxial->setEnabled(true);
       m_Controls.m_AxialLabel->setEnabled(true);
       m_Controls.m_ZWorldCoordinateSpinBox->setEnabled(true);
       connect(m_AxialStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
       connect(m_AxialStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorAxial->setEnabled(false);
       m_Controls.m_AxialLabel->setEnabled(false);
       m_Controls.m_ZWorldCoordinateSpinBox->setEnabled(false);
     }
 
     renderWindow = renderWindowPart->GetQmitkRenderWindow("sagittal");
     if (renderWindow)
     {
       if (m_SagittalStepper) m_SagittalStepper->deleteLater();
       m_SagittalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorSagittal,
                                                   renderWindow->GetSliceNavigationController()->GetSlice(),
                                                   "sliceNavigatorSagittalFromSimpleExample");
       m_Controls.m_SliceNavigatorSagittal->setEnabled(true);
       m_Controls.m_SagittalLabel->setEnabled(true);
       m_Controls.m_YWorldCoordinateSpinBox->setEnabled(true);
       connect(m_SagittalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
       connect(m_SagittalStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorSagittal->setEnabled(false);
       m_Controls.m_SagittalLabel->setEnabled(false);
       m_Controls.m_YWorldCoordinateSpinBox->setEnabled(false);
     }
 
     renderWindow = renderWindowPart->GetQmitkRenderWindow("coronal");
     if (renderWindow)
     {
-      if (m_FrontalStepper) m_FrontalStepper->deleteLater();
-      m_FrontalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorFrontal,
+      if (m_CoronalStepper) m_CoronalStepper->deleteLater();
+      m_CoronalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorCoronal,
                                                  renderWindow->GetSliceNavigationController()->GetSlice(),
-                                                 "sliceNavigatorFrontalFromSimpleExample");
-      m_Controls.m_SliceNavigatorFrontal->setEnabled(true);
+                                                 "sliceNavigatorCoronalFromSimpleExample");
+      m_Controls.m_SliceNavigatorCoronal->setEnabled(true);
       m_Controls.m_CoronalLabel->setEnabled(true);
       m_Controls.m_XWorldCoordinateSpinBox->setEnabled(true);
-      connect(m_FrontalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
-      connect(m_FrontalStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
+      connect(m_CoronalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
+      connect(m_CoronalStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
-      m_Controls.m_SliceNavigatorFrontal->setEnabled(false);
+      m_Controls.m_SliceNavigatorCoronal->setEnabled(false);
       m_Controls.m_CoronalLabel->setEnabled(false);
       m_Controls.m_XWorldCoordinateSpinBox->setEnabled(false);
     }
 
     mitk::SliceNavigationController* timeController = renderWindowPart->GetTimeNavigationController();
     if (timeController)
     {
       if (m_TimeStepper) m_TimeStepper->deleteLater();
       m_TimeStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorTime,
                                               timeController->GetTime(),
                                               "sliceNavigatorTimeFromSimpleExample");
       m_Controls.m_SliceNavigatorTime->setEnabled(true);
       m_Controls.m_TimeLabel->setEnabled(true);
       connect(m_TimeStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorTime->setEnabled(false);
       m_Controls.m_TimeLabel->setEnabled(false);
     }
 
     this->OnRefetch();
     this->UpdateStatusBar();
   }
 }
 
 void QmitkImageNavigatorView::UpdateStatusBar()
 {
   if (m_IRenderWindowPart != nullptr)
   {
     mitk::Point3D position = m_IRenderWindowPart->GetSelectedPosition();
     mitk::BaseRenderer::Pointer baseRenderer = mitk::BaseRenderer::GetInstance(m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetVtkRenderWindow());
     auto globalCurrentTimePoint = baseRenderer->GetTime();
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
 
     mitk::DataStorage::SetOfObjects::ConstPointer nodes = GetDataStorage()->GetSubset(isImageData).GetPointer();
 
     if (nodes.IsNotNull())
     {
       mitk::Image::Pointer image3D;
       mitk::DataNode::Pointer node;
       mitk::DataNode::Pointer topSourceNode;
 
       int component = 0;
 
       node = mitk::FindTopmostVisibleNode(nodes, position, globalCurrentTimePoint, baseRenderer);
 
       if (node.IsNotNull())
       {
         bool isBinary(false);
         node->GetBoolProperty("binary", isBinary);
         if (isBinary)
         {
           mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = GetDataStorage()->GetSources(node, nullptr, true);
           if (!sourcenodes->empty())
           {
             topSourceNode = mitk::FindTopmostVisibleNode(sourcenodes, position, globalCurrentTimePoint, baseRenderer);
           }
           if (topSourceNode.IsNotNull())
           {
             image3D = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
             topSourceNode->GetIntProperty("Image.Displayed Component", component);
           }
           else
           {
             image3D = dynamic_cast<mitk::Image*>(node->GetData());
             node->GetIntProperty("Image.Displayed Component", component);
           }
         }
         else
         {
           image3D = dynamic_cast<mitk::Image*>(node->GetData());
           node->GetIntProperty("Image.Displayed Component", component);
         }
       }
 
       // get the position and pixel value from the image and build up status bar text
       auto statusBar = mitk::StatusBar::GetInstance();
 
       if (image3D.IsNotNull() && statusBar != nullptr)
       {
         itk::Index<3> p;
         image3D->GetGeometry()->WorldToIndex(position, p);
 
         auto pixelType = image3D->GetChannelDescriptor().GetPixelType().GetPixelType();
 
         if (pixelType == itk::IOPixelEnum::RGB || pixelType == itk::IOPixelEnum::RGBA)
         {
           std::string pixelValue = "Pixel RGB(A) value: ";
           pixelValue.append(ConvertCompositePixelValueToString(image3D, p));
           statusBar->DisplayImageInfo(position, p, globalCurrentTimePoint, pixelValue.c_str());
         }
         else if (pixelType == itk::IOPixelEnum::DIFFUSIONTENSOR3D || pixelType == itk::IOPixelEnum::SYMMETRICSECONDRANKTENSOR)
         {
           std::string pixelValue = "See ODF Details view. ";
           statusBar->DisplayImageInfo(position, p, globalCurrentTimePoint, pixelValue.c_str());
         }
         else
         {
           itk::Index<3> p;
           image3D->GetGeometry()->WorldToIndex(position, p);
           mitk::ScalarType pixelValue;
           mitkPixelTypeMultiplex5(
             mitk::FastSinglePixelAccess,
             image3D->GetChannelDescriptor().GetPixelType(),
             image3D,
             image3D->GetVolumeData(image3D->GetTimeGeometry()->TimePointToTimeStep(globalCurrentTimePoint)),
             p,
             pixelValue,
             component);
           statusBar->DisplayImageInfo(position, p, globalCurrentTimePoint, pixelValue);
         }
       }
       else
       {
         statusBar->DisplayImageInfoInvalid();
       }
     }
   }
 }
 
 void QmitkImageNavigatorView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_IRenderWindowPart = nullptr;
   m_Parent->setEnabled(false);
 }
 
 int QmitkImageNavigatorView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkImageNavigatorView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return 200;
   }
   else
   {
     return preferredResult;
   }
 }
 
 int QmitkImageNavigatorView::GetClosestAxisIndex(mitk::Vector3D normal)
 {
   // cos(theta) = normal . axis
   // cos(theta) = (a, b, c) . (d, e, f)
   // cos(theta) = (a, b, c) . (1, 0, 0) = a
   // cos(theta) = (a, b, c) . (0, 1, 0) = b
   // cos(theta) = (a, b, c) . (0, 0, 1) = c
   double absCosThetaWithAxis[3];
 
   for (int i = 0; i < 3; i++)
   {
     absCosThetaWithAxis[i] = fabs(normal[i]);
   }
   int largestIndex = 0;
   double largestValue = absCosThetaWithAxis[0];
   for (int i = 1; i < 3; i++)
   {
     if (absCosThetaWithAxis[i] > largestValue)
     {
       largestValue = absCosThetaWithAxis[i];
       largestIndex = i;
     }
   }
   return largestIndex;
 }
 
 void QmitkImageNavigatorView::SetBorderColors()
 {
   if (m_IRenderWindowPart)
   {
     QString decoColor;
 
     QmitkRenderWindow* renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("axial");
     if (renderWindow)
     {
       decoColor = GetDecorationColorOfGeometry(renderWindow);
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, decoColor);
       }
     }
 
     renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("sagittal");
     if (renderWindow)
     {
       decoColor = GetDecorationColorOfGeometry(renderWindow);
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, decoColor);
       }
     }
 
     renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("coronal");
     if (renderWindow)
     {
       decoColor = GetDecorationColorOfGeometry(renderWindow);
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, decoColor);
       }
     }
   }
 }
 
 QString QmitkImageNavigatorView::GetDecorationColorOfGeometry(QmitkRenderWindow* renderWindow)
 {
   QColor color;
   float rgb[3] = {1.0f, 1.0f, 1.0f};
   float rgbMax = 255.0f;
   mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow())->GetCurrentWorldPlaneGeometryNode()->GetColor(rgb);
   color.setRed(static_cast<int>(rgb[0]*rgbMax + 0.5));
   color.setGreen(static_cast<int>(rgb[1]*rgbMax + 0.5));
   color.setBlue(static_cast<int>(rgb[2]*rgbMax + 0.5));
   QString colorAsString = QString(color.name());
   return colorAsString;
 }
 
 void QmitkImageNavigatorView::SetBorderColor(int axis, QString colorAsStyleSheetString)
 {
   if (axis == 0)
   {
     this->SetBorderColor(m_Controls.m_XWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
   else if (axis == 1)
   {
     this->SetBorderColor(m_Controls.m_YWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
   else if (axis == 2)
   {
     this->SetBorderColor(m_Controls.m_ZWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
 }
 
 void QmitkImageNavigatorView::SetBorderColor(QDoubleSpinBox *spinBox, QString colorAsStyleSheetString)
 {
   assert(spinBox);
   spinBox->setStyleSheet(QString("border: 2px solid ") + colorAsStyleSheetString + ";");
 }
 
 void QmitkImageNavigatorView::SetStepSizes()
 {
   this->SetStepSize(0);
   this->SetStepSize(1);
   this->SetStepSize(2);
 }
 
 void QmitkImageNavigatorView::SetStepSize(int axis)
 {
   if (m_IRenderWindowPart)
   {
     mitk::BaseGeometry::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry3D();
 
     if (geometry.IsNotNull())
     {
       mitk::Point3D crossPositionInIndexCoordinates;
       mitk::Point3D crossPositionInIndexCoordinatesPlus1;
       mitk::Point3D crossPositionInMillimetresPlus1;
       mitk::Vector3D transformedAxisDirection;
 
       mitk::Point3D crossPositionInMillimetres = m_IRenderWindowPart->GetSelectedPosition();
       geometry->WorldToIndex(crossPositionInMillimetres, crossPositionInIndexCoordinates);
 
       crossPositionInIndexCoordinatesPlus1 = crossPositionInIndexCoordinates;
       crossPositionInIndexCoordinatesPlus1[axis] += 1;
 
       geometry->IndexToWorld(crossPositionInIndexCoordinatesPlus1, crossPositionInMillimetresPlus1);
 
       transformedAxisDirection = crossPositionInMillimetresPlus1 - crossPositionInMillimetres;
 
       int closestAxisInMillimetreSpace = this->GetClosestAxisIndex(transformedAxisDirection);
       double stepSize = transformedAxisDirection.GetNorm();
       this->SetStepSize(closestAxisInMillimetreSpace, stepSize);
     }
   }
 }
 
 void QmitkImageNavigatorView::SetStepSize(int axis, double stepSize)
 {
   if (axis == 0)
   {
     m_Controls.m_XWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
   else if (axis == 1)
   {
     m_Controls.m_YWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
   else if (axis == 2)
   {
     m_Controls.m_ZWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
 }
 
 void QmitkImageNavigatorView::OnMillimetreCoordinateValueChanged()
 {
   if (m_IRenderWindowPart)
   {
     mitk::TimeGeometry::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldTimeGeometry();
 
     if (geometry.IsNotNull())
     {
       mitk::Point3D positionInWorldCoordinates;
       positionInWorldCoordinates[0] = m_Controls.m_XWorldCoordinateSpinBox->value();
       positionInWorldCoordinates[1] = m_Controls.m_YWorldCoordinateSpinBox->value();
       positionInWorldCoordinates[2] = m_Controls.m_ZWorldCoordinateSpinBox->value();
 
       m_IRenderWindowPart->SetSelectedPosition(positionInWorldCoordinates);
     }
   }
 }
 
 void QmitkImageNavigatorView::OnRefetch()
 {
   if (m_IRenderWindowPart)
   {
     mitk::BaseGeometry::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry3D();
     mitk::TimeGeometry::ConstPointer timeGeometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldTimeGeometry();
 
     if (geometry.IsNull() && timeGeometry.IsNotNull())
     {
       mitk::TimeStepType timeStep = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetTime()->GetPos();
       geometry = timeGeometry->GetGeometryForTimeStep(timeStep);
       SetVisibilityOfTimeSlider(timeGeometry->CountTimeSteps());
     }
 
     if (geometry.IsNotNull())
     {
       mitk::BoundingBox::BoundsArrayType bounds = geometry->GetBounds();
 
       mitk::Point3D cornerPoint1InIndexCoordinates;
       cornerPoint1InIndexCoordinates[0] = bounds[0];
       cornerPoint1InIndexCoordinates[1] = bounds[2];
       cornerPoint1InIndexCoordinates[2] = bounds[4];
 
       mitk::Point3D cornerPoint2InIndexCoordinates;
       cornerPoint2InIndexCoordinates[0] = bounds[1];
       cornerPoint2InIndexCoordinates[1] = bounds[3];
       cornerPoint2InIndexCoordinates[2] = bounds[5];
 
       if (!geometry->GetImageGeometry())
       {
         cornerPoint1InIndexCoordinates[0] += 0.5;
         cornerPoint1InIndexCoordinates[1] += 0.5;
         cornerPoint1InIndexCoordinates[2] += 0.5;
         cornerPoint2InIndexCoordinates[0] -= 0.5;
         cornerPoint2InIndexCoordinates[1] -= 0.5;
         cornerPoint2InIndexCoordinates[2] -= 0.5;
       }
 
       mitk::Point3D crossPositionInWorldCoordinates = m_IRenderWindowPart->GetSelectedPosition();
 
       mitk::Point3D cornerPoint1InWorldCoordinates;
       mitk::Point3D cornerPoint2InWorldCoordinates;
 
       geometry->IndexToWorld(cornerPoint1InIndexCoordinates, cornerPoint1InWorldCoordinates);
       geometry->IndexToWorld(cornerPoint2InIndexCoordinates, cornerPoint2InWorldCoordinates);
 
       m_Controls.m_XWorldCoordinateSpinBox->blockSignals(true);
       m_Controls.m_YWorldCoordinateSpinBox->blockSignals(true);
       m_Controls.m_ZWorldCoordinateSpinBox->blockSignals(true);
 
       m_Controls.m_XWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[0], cornerPoint2InWorldCoordinates[0]));
       m_Controls.m_YWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[1], cornerPoint2InWorldCoordinates[1]));
       m_Controls.m_ZWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[2], cornerPoint2InWorldCoordinates[2]));
       m_Controls.m_XWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[0], cornerPoint2InWorldCoordinates[0]));
       m_Controls.m_YWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[1], cornerPoint2InWorldCoordinates[1]));
       m_Controls.m_ZWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[2], cornerPoint2InWorldCoordinates[2]));
 
       m_Controls.m_XWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[0]);
       m_Controls.m_YWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[1]);
       m_Controls.m_ZWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[2]);
 
       m_Controls.m_XWorldCoordinateSpinBox->blockSignals(false);
       m_Controls.m_YWorldCoordinateSpinBox->blockSignals(false);
       m_Controls.m_ZWorldCoordinateSpinBox->blockSignals(false);
 
       /// Calculating 'inverse direction' property.
 
       mitk::AffineTransform3D::MatrixType matrix = geometry->GetIndexToWorldTransform()->GetMatrix();
       matrix.GetVnlMatrix().normalize_columns();
       mitk::AffineTransform3D::MatrixType::InternalMatrixType inverseMatrix = matrix.GetInverse();
 
       for (int worldAxis = 0; worldAxis < 3; ++worldAxis)
       {
         QmitkRenderWindow* renderWindow =
             worldAxis == 0 ? m_IRenderWindowPart->GetQmitkRenderWindow("sagittal") :
             worldAxis == 1 ? m_IRenderWindowPart->GetQmitkRenderWindow("coronal") :
                              m_IRenderWindowPart->GetQmitkRenderWindow("axial");
 
         if (renderWindow)
         {
           const mitk::BaseGeometry* rendererGeometry = renderWindow->GetRenderer()->GetCurrentWorldGeometry();
 
           /// Because of some problems with the current way of event signalling,
           /// 'Modified' events are sent out from the stepper while the renderer
           /// does not have a geometry yet. Therefore, we do a nullptr check here.
           /// See bug T22122. This check can be resolved after T22122 got fixed.
           if (rendererGeometry)
           {
             int dominantAxis = itk::Function::Max3(
                 inverseMatrix[0][worldAxis],
                 inverseMatrix[1][worldAxis],
                 inverseMatrix[2][worldAxis]);
 
             bool referenceGeometryAxisInverted = inverseMatrix[dominantAxis][worldAxis] < 0;
             bool rendererZAxisInverted = rendererGeometry->GetAxisVector(2)[worldAxis] < 0;
 
             /// `referenceGeometryAxisInverted` tells if the direction of the corresponding axis
             /// of the reference geometry is flipped compared to the 'world direction' or not.
             ///
             /// `rendererZAxisInverted` tells if direction of the renderer geometry z axis is
             /// flipped compared to the 'world direction' or not. This is the same as the indexing
             /// direction in the slice navigation controller and matches the 'top' property when
             /// initialising the renderer planes. (If 'top' was true then the direction is
             /// inverted.)
             ///
             /// The world direction can be +1 ('up') that means right, anterior or superior, or
             /// it can be -1 ('down') that means left, posterior or inferior, respectively.
             ///
             /// If these two do not match, we have to invert the index between the slice navigation
             /// controller and the slider navigator widget, so that the user can see and control
             /// the index according to the reference geometry, rather than the slice navigation
             /// controller. The index in the slice navigation controller depends on in which way
             /// the reference geometry has been resliced for the renderer, and it does not necessarily
             /// match neither the world direction, nor the direction of the corresponding axis of
             /// the reference geometry. Hence, it is a merely internal information that should not
             /// be exposed to the GUI.
             ///
             /// So that one can navigate in the same world direction by dragging the slider
             /// right, regardless of the direction of the corresponding axis of the reference
             /// geometry, we invert the direction of the controls if the reference geometry axis
             /// is inverted but the direction is not ('inversDirection' is false) or the other
             /// way around.
 
             bool inverseDirection = referenceGeometryAxisInverted != rendererZAxisInverted;
 
             QmitkSliderNavigatorWidget* navigatorWidget =
                 worldAxis == 0 ? m_Controls.m_SliceNavigatorSagittal :
-                worldAxis == 1 ? m_Controls.m_SliceNavigatorFrontal :
+                worldAxis == 1 ? m_Controls.m_SliceNavigatorCoronal :
                                  m_Controls.m_SliceNavigatorAxial;
 
             navigatorWidget->SetInverseDirection(inverseDirection);
 
             // This should be a preference (see T22254)
             // bool invertedControls = referenceGeometryAxisInverted != inverseDirection;
             // navigatorWidget->SetInvertedControls(invertedControls);
           }
         }
       }
     }
 
     this->SetBorderColors();
 
   }
 }
 
 
 void QmitkImageNavigatorView::SetVisibilityOfTimeSlider(std::size_t timeSteps)
 {
   m_Controls.m_SliceNavigatorTime->setVisible(timeSteps > 1);
   m_Controls.m_TimeLabel->setVisible(timeSteps > 1);
 }
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.h b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.h
index 22f6fd5185..a9d687bf67 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.h
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.h
@@ -1,100 +1,100 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef _QMITKIMAGENAVIGATORVIEW_H_INCLUDED
 #define _QMITKIMAGENAVIGATORVIEW_H_INCLUDED
 
 #include <berryISizeProvider.h>
 
 #include <QmitkAbstractView.h>
 #include <mitkIRenderWindowPartListener.h>
 
 #include "ui_QmitkImageNavigatorViewControls.h"
 
 
 class QmitkStepperAdapter;
 
 /*!
  * \ingroup org_mitk_gui_qt_imagenavigator_internal
  *
  * \class QmitkImageNavigatorView
  *
  * \brief Provides a means to scan quickly through a dataset via Axial,
  * Coronal and Sagittal sliders, displaying millimetre location and stepper position.
  *
  * For images, the stepper position corresponds to a voxel index. For other datasets
  * such as a surface, it corresponds to a sub-division of the bounding box.
  *
  * \sa QmitkAbstractView
  */
 class QmitkImageNavigatorView :
     public QmitkAbstractView, public mitk::IRenderWindowPartListener,
     public berry::ISizeProvider
 {
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkImageNavigatorView();
 
   ~QmitkImageNavigatorView() override;
 
   void CreateQtPartControl(QWidget *parent) override;
 
   int GetSizeFlags(bool width) override;
   int ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult) override;
 
 protected slots:
 
   void OnMillimetreCoordinateValueChanged();
   void OnRefetch();
   void UpdateStatusBar();
 
 protected:
 
   void SetFocus() override;
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart) override;
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart *renderWindowPart) override;
 
   void SetBorderColors();
   void SetBorderColor(QDoubleSpinBox *spinBox, QString colorAsStyleSheetString);
   void SetBorderColor(int axis, QString colorAsStyleSheetString);
   void SetStepSizes();
   void SetStepSize(int axis);
   void SetStepSize(int axis, double stepSize);
   int  GetClosestAxisIndex(mitk::Vector3D normal);
   void SetVisibilityOfTimeSlider(std::size_t timeSteps);
 
   Ui::QmitkImageNavigatorViewControls m_Controls;
 
   QmitkStepperAdapter* m_AxialStepper;
   QmitkStepperAdapter* m_SagittalStepper;
-  QmitkStepperAdapter* m_FrontalStepper;
+  QmitkStepperAdapter* m_CoronalStepper;
   QmitkStepperAdapter* m_TimeStepper;
 
   QWidget* m_Parent;
 
   mitk::IRenderWindowPart* m_IRenderWindowPart;
   /**
    * @brief GetDecorationColorOfGeometry helper method to get the color of a helper geometry node.
    * @param renderWindow The renderwindow of the geometry
    * @return the color for decoration in QString format (#RRGGBB).
    */
   QString GetDecorationColorOfGeometry(QmitkRenderWindow *renderWindow);
 };
 
 #endif // _QMITKIMAGENAVIGATORVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorViewControls.ui b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorViewControls.ui
index de96d1e32b..e32f176466 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorViewControls.ui
@@ -1,244 +1,244 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkImageNavigatorViewControls</class>
  <widget class="QWidget" name="QmitkImageNavigatorViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>360</width>
     <height>440</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="2" column="2" colspan="3">
     <widget class="QmitkSliderNavigatorWidget" name="m_SliceNavigatorSagittal" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
     </widget>
    </item>
    <item row="1" column="2" colspan="3">
     <widget class="QmitkSliderNavigatorWidget" name="m_SliceNavigatorAxial" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>0</height>
       </size>
      </property>
     </widget>
    </item>
    <item row="3" column="2" colspan="3">
-    <widget class="QmitkSliderNavigatorWidget" name="m_SliceNavigatorFrontal" native="true">
+    <widget class="QmitkSliderNavigatorWidget" name="m_SliceNavigatorCoronal" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
     </widget>
    </item>
    <item row="4" column="2" colspan="3">
     <widget class="QmitkSliderNavigatorWidget" name="m_SliceNavigatorTime" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
     </widget>
    </item>
    <item row="1" column="0">
     <widget class="QLabel" name="m_AxialLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="text">
       <string>Axial</string>
      </property>
     </widget>
    </item>
    <item row="2" column="0">
     <widget class="QLabel" name="m_SagittalLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="text">
       <string>Sagittal</string>
      </property>
     </widget>
    </item>
    <item row="0" column="4">
     <widget class="QDoubleSpinBox" name="m_ZWorldCoordinateSpinBox">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="font">
       <font>
        <pointsize>8</pointsize>
       </font>
      </property>
      <property name="keyboardTracking">
       <bool>false</bool>
      </property>
      <property name="decimals">
       <number>2</number>
      </property>
      <property name="minimum">
       <double>-100000.000000000000000</double>
      </property>
      <property name="maximum">
       <double>100000.000000000000000</double>
      </property>
     </widget>
    </item>
    <item row="5" column="3" colspan="2">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>413</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="4" column="0">
     <widget class="QLabel" name="m_TimeLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="text">
       <string>Time</string>
      </property>
     </widget>
    </item>
    <item row="3" column="0">
     <widget class="QLabel" name="m_CoronalLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="text">
       <string>Coronal</string>
      </property>
     </widget>
    </item>
    <item row="0" column="0">
     <widget class="QLabel" name="m_LocationLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="text">
       <string>Loc. (mm)</string>
      </property>
     </widget>
    </item>
    <item row="0" column="3">
     <widget class="QDoubleSpinBox" name="m_YWorldCoordinateSpinBox">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="font">
       <font>
        <pointsize>8</pointsize>
       </font>
      </property>
      <property name="keyboardTracking">
       <bool>false</bool>
      </property>
      <property name="decimals">
       <number>2</number>
      </property>
      <property name="minimum">
       <double>-100000.000000000000000</double>
      </property>
      <property name="maximum">
       <double>100000.000000000000000</double>
      </property>
     </widget>
    </item>
    <item row="0" column="2">
     <widget class="QDoubleSpinBox" name="m_XWorldCoordinateSpinBox">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="font">
       <font>
        <pointsize>8</pointsize>
       </font>
      </property>
      <property name="keyboardTracking">
       <bool>false</bool>
      </property>
      <property name="decimals">
       <number>2</number>
      </property>
      <property name="minimum">
       <double>-100000.000000000000000</double>
      </property>
      <property name="maximum">
       <double>100000.000000000000000</double>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QmitkSliderNavigatorWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkSliderNavigatorWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <includes>
   <include location="local">QmitkDataStorageComboBox.h</include>
  </includes>
  <resources/>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.h b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.h
index 1e410ac03a..9aaab74c8c 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.h
+++ b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.h
@@ -1,126 +1,125 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef __Q_MITK_MATCHPOINT_H
 #define __Q_MITK_MATCHPOINT_H
 
 #include <QmitkAbstractView.h>
 
 #include <berryISelectionListener.h>
 #include <berryIPreferences.h>
 #include <berryIPreferencesService.h>
 #include <berryIBerryPreferences.h>
 
 //QT
 #include <QSortFilterProxyModel>
 
 // MatchPoint
 #include <mapDeploymentDLLHandle.h>
 #include <mapRegistrationAlgorithmBase.h>
 #include <mapMetaPropertyAlgorithmInterface.h>
 
 #include "ui_QmitkMatchPointBrowserControls.h"
 #include "QmitkMAPAlgorithmModel.h"
 #include "QmitkAlgorithmListModel.h"
 #include "mitkAlgorithmInfoSelectionProvider.h"
 
 /*!
 \brief MatchPoint
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
-\sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class QmitkMatchPointBrowser : public QmitkAbstractView
 {
     // this is needed for all Qt objects that should have a Qt meta-object
     // (everything that derives from QObject and wants to have signal/slots)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     /**
     * Creates smartpointer typedefs
     */
     berryObjectMacro(QmitkMatchPointBrowser);
 
         QmitkMatchPointBrowser();
     ~QmitkMatchPointBrowser() override;
 
     /**
     * \brief Called by the framework to indicate that the preferences have changed.
     * \param prefs not used, as we call RetrievePreferenceValues().
     */
     void OnPreferencesChanged(const berry::IBerryPreferences* prefs) override;
 
     protected slots:
 
     /**
     * @brief Connect all GUI elements to its corresponding slots
     */
     virtual void CreateConnections();
 
     /// \brief Called when the user clicks the GUI button
 
     void OnSearchFolderButtonPushed();
 
     void OnAlgoListSelectionChanged(const QModelIndex&);
 
     void OnSearchChanged(const QString&);
 
 protected:
     void CreateQtPartControl(QWidget* parent) override;
     void SetFocus() override;
 
     Ui::MatchPointBrowserControls m_Controls;
 
     //! [Qt Selection Provider]
     /** @brief this pointer holds the selection provider*/
     mitk::AlgorithmInfoSelectionProvider::Pointer m_SelectionProvider;
     //! [Qt Selection Provider]
 
 private:
     void SetSelectionProvider() override;
 
     void Error(QString msg);
 
     /**
     * \brief Called on startup and by OnPreferencesChanged to load all
     * preferences except the temporary folder into member variables.
     */
     void RetrieveAndStorePreferenceValues();
 
     void OnInvalidDeploymentEvent(const ::itk::Object *, const itk::EventObject &event);
     void OnValidDeploymentEvent(const ::itk::Object *, const itk::EventObject &event);
 
     /**
     * \brief Called to get hold of the actual preferences node.
     */
     berry::IBerryPreferences::Pointer RetrievePreferences();
 
     QWidget* m_Parent;
 
     ::map::deployment::DLLDirectoryBrowser::DLLInfoListType m_DLLInfoList;
 
     QStringList m_currentSearchPaths;
     QmitkAlgorithmListModel* m_algModel;
     QSortFilterProxyModel* m_filterProxy;
 
     ::map::deployment::DLLHandle::Pointer m_LoadedDLLHandle;
     ::map::algorithm::RegistrationAlgorithmBase::Pointer m_LoadedAlgorithm;
 };
 
 #endif // MatchPoint_h
 
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/QmitkMatchPoint.h b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/QmitkMatchPoint.h
index 7ac80659cd..b503f44bd9 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/QmitkMatchPoint.h
+++ b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/QmitkMatchPoint.h
@@ -1,206 +1,205 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef __Q_MITK_MATCHPOINT_H
 #define __Q_MITK_MATCHPOINT_H
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_QmitkMatchPointControls.h"
 
 #include <mitkImage.h>
 
 // MatchPoint
 #include <mapDeploymentDLLInfo.h>
 #include <mapDeploymentDLLHandle.h>
 #include <mapRegistrationAlgorithmBase.h>
 #include <mapIterativeAlgorithmInterface.h>
 #include <mapMultiResRegistrationAlgorithmInterface.h>
 #include <mapStoppableAlgorithmInterface.h>
 
 #include <mitkMAPRegistrationWrapper.h>
 
 class QmitkRegistrationJob;
 class QmitkMappingJob;
 
 /*!
 \brief MatchPoint
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
-\sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class QmitkMatchPoint : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   /**
   * Creates smartpointer typedefs
   */
   berryObjectMacro(QmitkMatchPoint);
 
   QmitkMatchPoint();
   ~QmitkMatchPoint() override;
 
 protected slots:
 
   /**
   * @brief Connect all GUI elements to its corresponding slots
   */
   virtual void CreateConnections();
 
   /// \brief Called when the user clicks the GUI button
   void OnLoadAlgorithmButtonPushed();
   void OnSelectedAlgorithmChanged();
   void OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
 
   void OnStartRegBtnPushed();
   void OnStopRegBtnPushed();
   void OnSaveLogBtnPushed();
 
   void OnRegJobError(QString err);
   void OnRegResultIsAvailable(mitk::MAPRegistrationWrapper::Pointer spResultRegistration,
                               const QmitkRegistrationJob* pRegJob);
   void OnRegJobFinished();
   void OnMapJobError(QString err);
   void OnMapResultIsAvailable(mitk::BaseData::Pointer spMappedData, const QmitkMappingJob* job);
   void OnAlgorithmIterated(QString info, bool hasIterationCount, unsigned long currentIteration);
   void OnLevelChanged(QString info, bool hasLevelCount, unsigned long currentLevel);
   void OnAlgorithmStatusChanged(QString info);
   void OnAlgorithmInfo(QString info);
 
 protected:
   void CreateQtPartControl(QWidget* parent) override;
 
   void SetFocus() override;
 
 private:
 
   /**
   * @brief Adapt the visibility of GUI elements depending on the current data  loaded
   */
   void AdaptFolderGUIElements();
 
   void Error(QString msg);
 
   void UpdateAlgorithmList();
 
   /**
   * checks if appropriated nodes are selected in the data manager. If nodes are selected,
   * they are stored m_MovingData and m_TargetData. It also sets the info lables accordingly.
   * @return True: All inputs are set and valid (images). False: At least one input is not set
   * or invalid */
   bool CheckInputs();
 
   /**
   * Updates the state of registration control buttons. Regarding to selected
   * inputs, loaded algorithm and its state.*/
   void ConfigureRegistrationControls();
 
   /**
   * Configures the progress bars according to the chosen algorithm.
   */
   void ConfigureProgressInfos();
 
   /**
   Configure the node selectors predicates and informations according to the selected algorithm.
   */
   void ConfigureNodeSelectors();
 
   /** Methods returns a list of all nodes in the data manager containing a registration wrapper.
     * The list may be empty.*/
   mitk::DataStorage::SetOfObjects::Pointer GetRegNodes() const;
 
   /** Returns a proposal for a (unique) default reg job name */
   std::string GetDefaultRegJobName() const;
 
   /** Returns the display name of the passed node. Normally it is just node->GetName().
    * if the node contains a point set it is additionally checked if the point set node
    * has a source node and its name will be added in parentheses.*/
   std::string GetInputNodeDisplayName(const mitk::DataNode* node) const;
 
   /** Returns the Pointer to the DLL info of the algorithm currently selected by the system.
   The info is received via m_AlgorithmSelectionListener.
   @return If there is no item selected the returning pointer
   will be null.
   */
   const map::deployment::DLLInfo* GetSelectedAlgorithmDLL() const;
 
   //! [Qt Selection Listener method and pointer]
   /**
   * @brief Method of berry::ISelectionListener that implements the selection listener functionality.
   * @param sourcepart The workbench part responsible for the selection change.
   * @param selection This parameter holds the current selection.
   *
   * @see ISelectionListener
   */
   void OnAlgorithmSelectionChanged(const berry::IWorkbenchPart::Pointer& sourcepart,
                                    const berry::ISelection::ConstPointer& selection);
 
   void UpdateAlgorithmSelection(berry::ISelection::ConstPointer selection);
 
   friend struct berry::SelectionChangedAdapter<QmitkMatchPoint>;
 
   QWidget* m_Parent;
 
   /** @brief this pointer holds the algorithm selection listener */
   QScopedPointer<berry::ISelectionListener> m_AlgorithmSelectionListener;
 
   ::map::deployment::DLLHandle::Pointer m_LoadedDLLHandle;
   ::map::algorithm::RegistrationAlgorithmBase::Pointer m_LoadedAlgorithm;
   ::map::deployment::DLLInfo::ConstPointer m_SelectedAlgorithmInfo;
 
   typedef map::algorithm::facet::IterativeAlgorithmInterface IIterativeAlgorithm;
   typedef map::algorithm::facet::MultiResRegistrationAlgorithmInterface IMultiResAlgorithm;
   typedef map::algorithm::facet::StoppableAlgorithmInterface IStoppableAlgorithm;
 
   mitk::DataNode::Pointer m_spSelectedTargetNode;
   mitk::DataNode::Pointer m_spSelectedMovingNode;
   /*Data of the selected target node that should be used for registration.
   Can be the direct return of node->GetData(), but can also be a sub
   set (like a special time frame).*/
   mitk::BaseData::ConstPointer m_spSelectedTargetData;
   /*Data of the selected moving node that should be used for registration.
   Can be the direct return of node->GetData(), but can also be a sub
   set (like a special time frame).*/
   mitk::BaseData::ConstPointer m_spSelectedMovingData;
 
   mitk::DataNode::Pointer m_spSelectedTargetMaskNode;
   mitk::DataNode::Pointer m_spSelectedMovingMaskNode;
   /*Data of the selected target mask node that should be used for registration.
   Can be the direct return of node->GetData(), but can also be a sub
   set (like a special time frame).*/
   mitk::Image::ConstPointer m_spSelectedTargetMaskData;
   /*Data of the selected moving mask node that should be used for registration.
   Can be the direct return of node->GetData(), but can also be a sub
   set (like a special time frame).*/
   mitk::Image::ConstPointer m_spSelectedMovingMaskData;
 
   // boolean variables to control visibility of GUI elements
   bool m_CanLoadAlgorithm;
   bool m_ValidInputs;
   bool m_Working;
 
   Ui::MatchPointAdvancedControls m_Controls;
 };
 
 #endif // MatchPoint_h
 
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/QmitkMatchPointRegistrationEvaluator.h b/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/QmitkMatchPointRegistrationEvaluator.h
index 5aaa24643b..ca79c1c513 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/QmitkMatchPointRegistrationEvaluator.h
+++ b/Plugins/org.mitk.gui.qt.matchpoint.evaluator/src/internal/QmitkMatchPointRegistrationEvaluator.h
@@ -1,115 +1,114 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef __Q_MITK_MATCHPOINT_REGISTRATION_EVALUATOR_H
 #define __Q_MITK_MATCHPOINT_REGISTRATION_EVALUATOR_H
 
 #include <QmitkAbstractView.h>
 #include <mitkIRenderWindowPartListener.h>
 #include <QmitkSliceNavigationListener.h>
 
 #include "ui_QmitkMatchPointRegistrationEvaluator.h"
 
 /*!
 \brief QmitkMatchPointRegistrationEvaluator
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
-\sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class QmitkMatchPointRegistrationEvaluator : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   /**
   * Creates smartpointer typedefs
   */
   berryObjectMacro(QmitkMatchPointRegistrationEvaluator);
 
   QmitkMatchPointRegistrationEvaluator();
   ~QmitkMatchPointRegistrationEvaluator() override;
 
   void CreateQtPartControl(QWidget *parent) override;
 
 protected slots:
 
     /// \brief Called when the user clicks the GUI button
 
   void OnEvalBtnPushed();
   void OnStopBtnPushed();
   void OnSettingsChanged(mitk::DataNode*);
 
   void OnSliceChanged();
 
   void OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
 
 protected:
   void NodeRemoved(const mitk::DataNode* node) override;
 
   void SetFocus() override;
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
   Ui::MatchPointRegistrationEvaluatorControls m_Controls;
 
 private:
   QWidget *m_Parent;
 
   void Error(QString msg);
 
   /**
   * Checks if appropriated nodes are selected in the data manager. If nodes are selected,
   * they are stored m_spSelectedRegNode, m_spSelectedInputNode and m_spSelectedRefNode.
   * They are also checked for vadility and stored in m_ValidInput,... .
   * It also sets the info lables accordingly.*/
   void CheckInputs();
 
   /**
   * Updates the state of controls regarding to selected eval object.*/
   void ConfigureControls();
 
   /**
   Configure the node selectors predicates according to the selected algorithm.
   */
   void ConfigureNodePredicates();
 
   mitk::DataNode::Pointer m_selectedEvalNode;
 
   QmitkSliceNavigationListener m_SliceChangeListener;
 
   itk::TimeStamp m_selectedNodeTime;
   itk::TimeStamp m_currentPositionTime;
 
   bool m_activeEvaluation;
 
   /** @brief currently valid selected position in the inspector*/
   mitk::Point3D m_currentSelectedPosition;
   /** @brief currently selected timepoint*/
   mitk::TimePointType m_currentSelectedTimePoint;
 
   mitk::DataNode::Pointer m_spSelectedRegNode;
   mitk::DataNode::Pointer m_spSelectedMovingNode;
   mitk::DataNode::Pointer m_spSelectedTargetNode;
 
   static const std::string HelperNodeName;
 };
 
 #endif // MatchPoint_h
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.h b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.h
index 79786b709f..54e9cf1e3e 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.h
+++ b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.h
@@ -1,149 +1,148 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef __Q_MITK_MATCHPOINT_REGISTRATION_MANIPULATOR_H
 #define __Q_MITK_MATCHPOINT_REGISTRATION_MANIPULATOR_H
 
 #include <QmitkAbstractView.h>
 #include <mitkIRenderWindowPartListener.h>
 #include <QmitkSliceNavigationListener.h>
 #include <mitkMAPRegistrationWrapper.h>
 #include <itkEuler3DTransform.h>
 #include "ui_QmitkMatchPointRegistrationManipulator.h"
 
 
 class QmitkMappingJob;
 
 /*!
 \brief QmitkMatchPointRegistrationManipulator
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
-\sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class QmitkMatchPointRegistrationManipulator : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   /**
   * Creates smartpointer typedefs
   */
   berryObjectMacro(QmitkMatchPointRegistrationManipulator);
 
   QmitkMatchPointRegistrationManipulator();
   ~QmitkMatchPointRegistrationManipulator() override;
 
   void CreateQtPartControl(QWidget *parent) override;
 
   protected slots:
 
     /// \brief Called when the user clicks the GUI button
 
   void OnStartBtnPushed();
   void OnCancelBtnPushed();
   void OnStoreBtnPushed();
   void OnSettingsChanged(mitk::DataNode*);
 
   void OnRegSourceChanged();
   void OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
 
   void OnRegistrationChanged();
 
   void OnCenterTypeChanged(int);
 
   void OnSliceChanged();
 
   void OnMapResultIsAvailable(mitk::BaseData::Pointer spMappedData, const QmitkMappingJob* job);
 
   void Error(QString msg);
 
 protected:
 
   void NodeRemoved(const mitk::DataNode* node) override;
 
   void SetFocus() override;
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
   Ui::MatchPointRegistrationManipulatorControls m_Controls;
 
 private:
   QWidget *m_Parent;
 
 
 
   /** Methods returns a list of all eval nodes in the data manager.*/
   QList<mitk::DataNode::Pointer> GetEvalNodes();
 
   /**
   * Checks if appropriated nodes are selected in the data manager. If nodes are selected,
   * they are stored m_spSelectedRegNode, m_spSelectedInputNode and m_spSelectedRefNode.
   * They are also checked for validity.*/
   void CheckInputs();
 
   /**
   * Updates the state of controls regarding to the state of the view and it objects.*/
   void ConfigureControls();
 
   /**
   Configure the node selectors predicates according to the selected algorithm.
   */
   void ConfigureNodePredicates();
 
   /** Initialize the state of the view, so the manipulation can start.*/
   void InitSession();
 
   /** Stops session, removes all obsolete members (e.g. RegEvalObject). After that the view is in a valid but inactive state.*/
   void StopSession();
 
   void ConfigureTransformCenter(int centerType);
 
   mitk::DataNode::Pointer m_EvalNode;
 
   QmitkSliceNavigationListener m_SliceChangeListener;
 
   itk::TimeStamp m_selectedNodeTime;
   itk::TimeStamp m_currentPositionTime;
 
   bool m_activeManipulation;
 
   /** @brief currently valid selected position in the inspector*/
   mitk::Point3D m_currentSelectedPosition;
   /** @brief currently selected timepoint*/
   mitk::TimePointType m_currentSelectedTimePoint;
 
   mitk::DataNode::Pointer m_SelectedPreRegNode;
 
   mitk::DataNode::Pointer m_SelectedMovingNode;
   mitk::DataNode::Pointer m_SelectedTargetNode;
 
 
   mitk::MAPRegistrationWrapper::Pointer m_CurrentRegistrationWrapper;
   map::core::RegistrationBase::Pointer m_CurrentRegistration;
   using MAPRegistrationType = map::core::Registration<3, 3>;
   MAPRegistrationType::Pointer m_SelectedPreReg;
 
   bool m_internalUpdate;
   static const std::string HelperNodeName;
 };
 
 #endif // MatchPoint_h
 
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.h b/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.h
index 05287a2d75..f505b8316a 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.h
+++ b/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.h
@@ -1,159 +1,158 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef __Q_MITK_MATCHPOINT_MAPPER_H
 #define __Q_MITK_MATCHPOINT_MAPPER_H
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include <QSortFilterProxyModel>
 
 #include "ui_QmitkMatchPointMapper.h"
 
 #include "QmitkMappingJob.h"
 
 /*!
   \brief QmitkMatchPointMapper
 
   View class that implements the logic/functionality to map point sets or images based on MatchPoint registration objects.
 
-  \sa QmitkFunctionality
   \ingroup ${plugin_target}_internal
   */
 class QmitkMatchPointMapper : public QmitkAbstractView
 {
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     /**
      * Creates smartpointer typedefs
      */
     berryObjectMacro(QmitkMatchPointMapper);
 
     QmitkMatchPointMapper();
 
     void CreateQtPartControl(QWidget *parent) override;
 
 protected slots:
 
     /**
      * @brief Connect all GUI elements to its corresponding slots
      */
     virtual void CreateConnections();
 
     void OnManualRefChecked();
     void OnLinkSampleFactorChecked();
 
     void OnXFactorChanged(double d);
 
     void OnMapBtnPushed();
     void OnRefineBtnPushed();
 
     void OnMapJobError(QString err);
     void OnMapResultIsAvailable(mitk::BaseData::Pointer spMappedData, const QmitkMappingJob* job);
     void OnMappingInfo(QString info);
 
     void OnRegNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
     void OnInputNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
     void OnReferenceNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
 
 protected:
     void SetFocus() override;
 
     Ui::MatchPointMapperControls m_Controls;
 
 private:
     QWidget *m_Parent;
 
     void Error(QString msg);
 
     /** Method checks if the currently selected reg node has a direct kernel that
      * can be decomposed in a rotation matrix and a offset. If this is true, true
      * is returned. In all other cases false is returned.*/
     bool IsAbleToRefineGeometry() const;
 
     /** Method checks if the currently selected input is a binary image (property binary == true).
      * If this is true, true is returned. In all other cases false is returned.*/
     bool IsBinaryInput() const;
 
     /** Method checks if the currently selected input is a point set.
      * If this is true, true is returned. In all other cases false is returned.*/
     bool IsPointSetInput() const;
 
     /** If a registration node is set, this function determines the auto reference node.
      * The auto reference node is the node of the target data used to determine the
      * registration object or, if the first cannot be determined, the currently selected input
      * node.
      * @return Pointer to the reference node (target data of the registration algorithm run).
      * Function may return nullptr if the referenced node cannot be found or is not defined
      * by the registration.*/
     mitk::DataNode::Pointer GetAutoRefNodeByReg();
 
     /**
      * Checks if appropriated nodes are selected in the data manager. If nodes are selected,
      * they are stored m_spSelectedRegNode, m_spSelectedInputNode and m_spSelectedRefNode.
      * They are also checked for vadility and stored in m_ValidInput,... .
      * It also sets the info lables accordingly.*/
     void CheckInputs();
 
     /** Methods checks the validity of the currently stored
      * m_spSelectedRegNode, m_spSelectedInputNode and m_spSelectedRefNode.
      * Results are returned via the parameters. Details of the evaluation are
      * printed to the log widget.*/
     void CheckNodesValidity(bool& validReg, bool& validInput, bool& validRef);
 
     /**
      * Updates the state of mapping control button regarding to selected
      * input, registration and reference.*/
     void ConfigureMappingControls();
 
     /**
      * Configures the progress bars accoarding to the choosen algorithm.
      */
     void ConfigureProgressInfos();
 
     /**
     Configure the reg node selector predicates. If a input pointer is passed,
     the predicate will be configured according to the input.
     */
     void ConfigureRegNodePredicate(const mitk::DataNode* input = nullptr);
     /**
     Configure the input and ref node selector predicates. If a reg pointer is passed,
     the predicate will be configured according to the input.
     */
     void ConfigureNodePredicates(const mitk::DataNode* reg = nullptr);
 
 
     /**
      * Used to generate, configure and execute a mapping job regarding the
      * current settings.
      * @param doGeometryRefinement Set true if only a geometry refinement should be done.
      * Set to false if a mapping/resampling of the input should be done.*/
     void SpawnMappingJob(bool doGeometryRefinement = false);
 
     mitk::DataNode::Pointer m_spSelectedRegNode;
     mitk::DataNode::Pointer m_spSelectedInputNode;
     mitk::DataNode::Pointer m_spSelectedRefNode;
 
     /** used for the internal logic to indicate of the current settings
      are set for mapping binary images (used by ConfigureMappingControls()).*/
     bool m_preparedForBinaryInput;
 };
 
 #endif // MatchPoint_h
 
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.h b/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.h
index b24a326d2e..b05981c2ab 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.h
+++ b/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.h
@@ -1,159 +1,158 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef __Q_MITK_MATCHPOINT_REGISTRATION_VISUALIZER_H
 #define __Q_MITK_MATCHPOINT_REGISTRATION_VISUALIZER_H
 
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include <QSortFilterProxyModel>
 
 #include "mitkMAPRegistrationWrapper.h"
 
 #include "ui_QmitkMatchPointRegistrationVisualizer.h"
 
 
 /*!
   \brief QmitkMatchPointRegistrationVisualizer
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
-  \sa QmitkFunctionality
   \ingroup ${plugin_target}_internal
   */
 class QmitkMatchPointRegistrationVisualizer : public QmitkAbstractView
 {
     // this is needed for all Qt objects that should have a Qt meta-object
     // (everything that derives from QObject and wants to have signal/slots)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     /**
      * Creates smartpointer typedefs
      */
     berryObjectMacro(QmitkMatchPointRegistrationVisualizer);
 
         QmitkMatchPointRegistrationVisualizer();
 
     void CreateQtPartControl(QWidget* parent) override;
 
     /** Returns the registration currently handled by the plugin.
      * May return nullptr, if no registration is selected/handled by
      * the plugin*/
     mitk::MAPRegistrationWrapper* GetCurrentRegistration();
 
 protected slots:
     /**
      * @brief Connect all GUI elements to its corresponding slots
      */
     virtual void CreateConnections();
 
     void OnStyleButtonPushed();
     void OnDirectionChanged(int index);
 
     void OnUpdateBtnPushed();
 
     void OnColorInterpolationChecked(bool);
 
     void OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
 
     void TransferFOVRefGeometry();
 
 protected:
     void SetFocus() override;
 
     void ActualizeRegInfo(mitk::MAPRegistrationWrapper* currentReg);
 
     Ui::MatchPointRegVisControls* m_Controls;
 
 private:
     QWidget* m_Parent;
 
     void Error(QString msg);
 
     void CheckInputs();
 
     /** Function returns the first data node containing a registration wrapper
      * in the current selection of the data manager. If nothing is selected or
      * no registration wrapper is selected it return nullptr.*/
     mitk::DataNode::Pointer GetSelectedRegNode() const;
 
     /** If a registration node is set, this function determines the relevant referenced node.
      * The reference node is the node of the target or moving data (depending on the selected directions)
      * used to determine the* registration object.
      * @return Pointer to the reference node (moving or target data of the registration algorithm run).
      * Function may return nullptr if the referenced node cannot be found or is not defined
      * by the registration.*/
     mitk::DataNode::Pointer GetRefNodeOfReg(bool target) const;
 
     /** Methods returns the first node selected in the data manager that does
      * NOT contain a registration wrapper and has a data pointer with a geometry.
      * Returned pointer may be nullptr if nothing is selected or no appropriate data
      * node is selected.*/
     mitk::DataNode::Pointer GetSelectedDataNode();
 
     /** Methods checks if the given gridRes is larger than maxGridRes and scales down the spacing if necessary.
      * @param gridRes the resolution of the "grid".
      * @param spacing the spacing that would be used on the grid.
      * @param maxGridRes the maximum resolution of the "grid".*/
     mitk::ScalarType GetSaveSpacing(mitk::ScalarType gridRes, mitk::ScalarType spacing,
         unsigned int maxGridRes) const;
 
     /**
      * Checks for mandatory node properties and defines them with default values if they are missing.*/
     void InitRegNode();
 
     /**
      * Updates the gui controls regarding the current state of the instance.*/
     void ConfigureVisualizationControls();
 
     /**
     Configure the node selectors predicates according to the selected algorithm.
     */
     void ConfigureNodePredicates();
 
     /**
      * Updates the properties of the selected node according to the states of the gui controls.*/
     void StoreStateInNode();
 
     /**
      * Updates the state of the gui controls according to the properties of the selected node.*/
     void LoadStateFromNode();
 
     /**
      * Checks accordung to the current direction if there is a default FOV ref and sets it,
      * if the current FOV ref is not locked.*/
     void CheckAndSetDefaultFOVRef();
 
     void UpdateOrientationMatrixWidget();
 
     /**indicates if the gui updates is triggered internally or by user. Needed to
      * avoid update loops by ConfigureVisualizationControlls();*/
     bool m_internalUpdateGuard;
 
     mitk::DataNode::Pointer m_spSelectedFOVRefNode;
     mitk::DataNode::Pointer m_spSelectedRegNode;
 
     /**Used to store informations about the FOV reference orientation. Default is identity matrix.*/
     mitk::AffineTransform3D::MatrixType m_FOVRefOrientation;
 };
 
 #endif // MatchPoint_h
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
index 0cac52c084..d37a5712c8 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
@@ -1,90 +1,90 @@
 /**
 \page org_mitk_views_measurement The Measurement View
 
 \imageMacro{measurement-dox.svg,"Icon of the Measurement View",2.00}
 
 <h1>Overview</h1>
 
 The Measurement view allows you to measure distances, angles, paths and several geometric figures on 2D images or image slices of 3D and 4D images. The measurement view is repeatedly useable with the same or different measurement figures that are related to the chosen image and can be saved together with it for future use. 
 
 
 \imageMacro{QmitkMeasurementToolbox_BasicScreenEdited.jpg,"Image with measurements",16.00}
 
 
 <h1>Usage</h1>
 
-The first step to perform measurements is to select a reference image on top of the view. All resulting measurements will be assigned as child nodes of the image in the data manager. The standard working plane is 'Axial' but the other standard view planes ('Saggital' and 'Coronal') are also valid for measurements. 
+The first step to perform measurements is to select a reference image on top of the view. All resulting measurements will be assigned as child nodes of the image in the data manager. The standard working plane is 'Axial' but the other standard view planes ('Sagittal' and 'Coronal') are also valid for measurements. 
 
 
 \imageMacro{QmitkMeasurementToolbox_MeasurementView.jpg,"Measurement View",7.60}
 
 After selecting an image, you can click on any of the geometrical symbols. The respective measurement will appear as soon as you click on the image location you want to measure.
 
 The view offers a variety of measurement options that are introduced in the following:
 
 <ul>
 <li> <b>Line:</b>
 
 Draws a line between two set points and returns the distance between these points.
 
 <li> <b>Path:</b>
 
 Draws a line between several set points (two and more) and calculates the overall length, which is all lines length summed up. Add the final point by double left-click.
 
 <li> <b>Angle:</b>
 
 Draws two lines from three set points connected in the second set point and return the inner angle at the second point.
 
 <li> <b>Four Point / Double Angle:</b>
 
 Draws two lines that may but do not have to intersect from four set points. The returned angle is the one depicted in the icon.
 
 <li> <b>Circle:</b>
 
 Draws a circle by setting two points, whereas the first set point is the center and the second the radius of the circle. The measured values are the radius and the included area.
 
 <li> <b>Ellipse:</b>
 
 Draws an ellipse that can be modified by three points. The middle point can be used to move the whole measurement. The lower point modifies the ellipse axes. The right point can be used to modify the radius of the ellipse. The measured values are the major and minor axes and the area.
 
 <li> <b>Double Ellipse:</b>
 
 Draws two ellipses by adjusting four points. The middle point can be used to move the whole measurement. The left point is used to adjust the distance between the two ellipses. The lower point modifies the ellipse axes. The right point can be used to modify the radius of the ellipse. Can be used for measuring e.g. the wall thickness of a vessel. The measured values are the major and minor axes and the thickness.
 
 <li> <b>Rectangle:</b>
 
 Draws a rectangle by setting two points at the opposing edges of the rectangle starting with the upper left corner. The measured values are the circumference and the included area.
 
 <li> <b>Polygon:</b>
 
 Draws a closed polygon that can have an arbitrary number of points. New points are added by left mouse-click. To finish the drawing the user can double click on the last control point. The measured values are circumference and area.
 
 <li> <b>Bezier curve:</b>
 
 Draws a bezier curve by adding some control points with left mouse-click. To finish the drawing the user can double-click on the last control point. The measured value is the length of the bezier curve.
 
 <li> <b>Subdivision Polygon:</b>
 
 Draws a closed subdivision polygon by adding some control points with left mouse-click. To finish the drawing the user can double-click on the last control point. The measured value is the circumference of the polygon.
 </ul>
 
 <h2>Fixed sizes of measurement figures</h2>
 The measurement view offers a fixed size for circle and double ellipses to preset a radius and a thickness. This is useful e.g. for diagnostic studies where you want to derive gray value statistics from a well defined region.
 
 <h2>Modify measurements</h2>
 
 All measurements can be modified later on by moving the respective control points. Note that they can only be modified if the view is open.
 
 <h2>Multiple measurement figures</h2>
 
 When applying more than one measurement figure to the image the actual measurement figure is depicted in red and the displayed values belong to this measurement figure. All other measurement figures appear white. They can be selected by a left-mouse click on the respective node.
 
 
 <h2>Save the measurement information</h2>
 The entire scene containing the image and the measurement figures can be saved for future use. Scenes are saved with a '.mitk' extension by pressing 'Save Project' and contain all nodes and relevant information. Alternatively, you can just save the measurement solely (with file extension '.pf') by right-click on the node in the data manager.
 
 The content of the measurement widget can be copied to the clipboard with the corresponding button for further use in a table calculation program (e.g. Open Office Calc etc.).
 
 <h2>Remove measurement figures or image</h2>
 If the single measurement figures or the image is not needed any longer, it can be removed solely or as an entire group. The image can't be removed without simultaneously removing all the dependent measurement figures that belong to the image tree in the data manager. To remove, just select the wanted items in the data manager list by right-clicking on the respective node or, if several items wanted to be removed, right-click on all wanted by simultaneously holding the ctrl-button pressed.
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.multilabelsegmentation/manifest_headers.cmake
index 54eb90ad33..97ba4ee1c4 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK MultiLabelSegmentation")
 set(Plugin-Version "1.0.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
 set(Plugin-ContactAddress "http://www.mitk.org")
-set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager)
+set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.datamanager org.mitk.gui.qt.segmentation)
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertMaskToLabelAction.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertMaskToLabelAction.cpp
index 0a23d04b1a..9485543eb2 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertMaskToLabelAction.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertMaskToLabelAction.cpp
@@ -1,97 +1,97 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #include "QmitkConvertMaskToLabelAction.h"
 
 #include "mitkRenderingManager.h"
 #include "mitkLabelSetImage.h"
 #include "mitkToolManagerProvider.h"
 
 //needed for qApp
 #include <qcoreapplication.h>
 
 QmitkConvertMaskToLabelAction::QmitkConvertMaskToLabelAction()
 {
 }
 
 QmitkConvertMaskToLabelAction::~QmitkConvertMaskToLabelAction()
 {
 }
 
 void QmitkConvertMaskToLabelAction::Run( const QList<mitk::DataNode::Pointer> &selectedNodes )
 {
-  mitk::ToolManager::Pointer toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
+  mitk::ToolManager::Pointer toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
 
   mitk::DataNode* workingNode = toolManager->GetWorkingData(0);
   if (!workingNode)
   {
     MITK_INFO << "There is no available segmentation. Please load or create one before using this tool.";
     return;
   }
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>( workingNode->GetData() );
   assert(workingImage);
 
   foreach ( mitk::DataNode::Pointer maskNode, selectedNodes )
   {
     if (maskNode)
     {
       mitk::Image* mask = dynamic_cast<mitk::Image*>(maskNode->GetData() );
       if (!mask) continue;
 
       std::string name = maskNode->GetName();
       mitk::Color color;
       mitk::ColorProperty::Pointer colorProp;
       maskNode->GetProperty(colorProp,"color");
       if (colorProp.IsNull()) continue;
       color = colorProp->GetValue();
       workingImage->GetLabelSet()->AddLabel(name,color);
       //workingImage->AddLabelEvent.Send();
 
       try
       {
         workingImage->MaskStamp( mask, false );
       }
       catch ( mitk::Exception& e )
       {
         MITK_ERROR << "Exception caught: " << e.GetDescription();
         return;
       }
 
       maskNode->SetVisibility(false);
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
     else
     {
       MITK_INFO << "   a nullptr node was selected";
     }
   }
 }
 
 void QmitkConvertMaskToLabelAction::SetSmoothed(bool /*smoothed*/)
 {
  //not needed
 }
 
 void QmitkConvertMaskToLabelAction::SetDecimated(bool /*decimated*/)
 {
   //not needed
 }
 
 void QmitkConvertMaskToLabelAction::SetDataStorage(mitk::DataStorage* /*dataStorage*/)
 {
   //not needed
 }
 
 void QmitkConvertMaskToLabelAction::SetFunctionality(berry::QtViewPart* /*functionality*/)
 {
   //not needed
 }
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertSurfaceToLabelAction.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertSurfaceToLabelAction.cpp
index e9f5716fa4..b4311d7105 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertSurfaceToLabelAction.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkConvertSurfaceToLabelAction.cpp
@@ -1,102 +1,102 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #include "QmitkConvertSurfaceToLabelAction.h"
 
 #include "mitkRenderingManager.h"
 #include "mitkLabelSetImage.h"
 #include "mitkToolManagerProvider.h"
 #include <mitkSurface.h>
 
 //needed for qApp
 #include <qcoreapplication.h>
 #include <QApplication>
 
 QmitkConvertSurfaceToLabelAction::QmitkConvertSurfaceToLabelAction()
 {
 }
 
 QmitkConvertSurfaceToLabelAction::~QmitkConvertSurfaceToLabelAction()
 {
 }
 
 void QmitkConvertSurfaceToLabelAction::Run( const QList<mitk::DataNode::Pointer> &selectedNodes )
 {
-  mitk::ToolManager::Pointer toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
+  mitk::ToolManager::Pointer toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
 
   mitk::DataNode* workingNode = toolManager->GetWorkingData(0);
   if (!workingNode)
   {
     MITK_INFO << "There is no available segmentation. Please load or create one before using this tool.";
     return;
   }
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>( workingNode->GetData() );
   assert(workingImage);
 
   foreach ( mitk::DataNode::Pointer surfaceNode, selectedNodes )
   {
     if (surfaceNode)
     {
       mitk::Surface* surface = dynamic_cast<mitk::Surface*>(surfaceNode->GetData() );
       if (!surface) continue;
 
       std::string name = surfaceNode->GetName();
       mitk::Color color;
       mitk::ColorProperty::Pointer colorProp;
       surfaceNode->GetProperty(colorProp,"color");
       if (colorProp.IsNull()) continue;
       color = colorProp->GetValue();
       workingImage->GetLabelSet()->AddLabel(name,color);
       //workingImage->AddLabelEvent.Send();
 
       try
       {
         QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
 //        workingImage->SurfaceStamp( surface, false );
         QApplication::restoreOverrideCursor();
       }
       catch ( mitk::Exception& e )
       {
         QApplication::restoreOverrideCursor();
         MITK_ERROR << "Exception caught: " << e.GetDescription();
         return;
       }
 
       surfaceNode->SetVisibility(false);
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
     else
     {
       MITK_INFO << "   a nullptr node was selected";
     }
   }
 }
 
 void QmitkConvertSurfaceToLabelAction::SetSmoothed(bool /*smoothed*/)
 {
  //not needed
 }
 
 void QmitkConvertSurfaceToLabelAction::SetDecimated(bool /*decimated*/)
 {
   //not needed
 }
 
 void QmitkConvertSurfaceToLabelAction::SetDataStorage(mitk::DataStorage* /*dataStorage*/)
 {
   //not needed
 }
 
 void QmitkConvertSurfaceToLabelAction::SetFunctionality(berry::QtViewPart* /*functionality*/)
 {
   //not needed
 }
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelSegmentationAction.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelSegmentationAction.cpp
index f993c5e3fa..caef6ce886 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelSegmentationAction.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkCreateMultiLabelSegmentationAction.cpp
@@ -1,100 +1,116 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkCreateMultiLabelSegmentationAction.h"
 
 #include "mitkLabelSetImage.h"
 #include "mitkLabelSetImageHelper.h"
 
+#include <QmitkStaticDynamicSegmentationDialog.h>
+
 #include "QMessageBox"
 
 QmitkCreateMultiLabelSegmentationAction::QmitkCreateMultiLabelSegmentationAction()
 {
 }
 
 QmitkCreateMultiLabelSegmentationAction::~QmitkCreateMultiLabelSegmentationAction()
 {
 }
 
 void QmitkCreateMultiLabelSegmentationAction::Run(const QList<mitk::DataNode::Pointer>& selectedNodes)
 {
   if (m_DataStorage.IsNull())
   {
     auto message = tr("Data storage not set.");
     MITK_ERROR << message;
     QMessageBox::warning(nullptr, "New segmentation", message);
     return;
   }
 
-  for ( const auto &referenceNode : selectedNodes )
+  for (const auto& referenceNode : selectedNodes)
   {
     if (referenceNode.IsNull())
     {
       continue;
     }
 
-    mitk::Image* referenceImage = dynamic_cast<mitk::Image*>(referenceNode->GetData());
-    if (nullptr == referenceImage)
+    mitk::Image::ConstPointer  referenceImage = dynamic_cast<mitk::Image*>(referenceNode->GetData());
+    if (referenceImage.IsNull())
     {
       MITK_WARN << "Could not create multi label segmentation for non-image node.";
       continue;
     }
 
+    if (referenceImage->GetDimension() <= 1)
+    {
+      MITK_WARN << "Segmentation is currently not supported for 2D images.";
+      continue;
+    }
+
+    auto segTemplateImage = referenceImage;
+    if (referenceImage->GetDimension() > 3)
+    {
+      QmitkStaticDynamicSegmentationDialog dialog(nullptr);
+      dialog.SetReferenceImage(referenceImage.GetPointer());
+      dialog.exec();
+      segTemplateImage = dialog.GetSegmentationTemplate();
+    }
+
     mitk::DataNode::Pointer newSegmentationNode;
     try
     {
-      newSegmentationNode =
-        mitk::LabelSetImageHelper::CreateNewSegmentationNode(referenceNode, referenceImage);
+      newSegmentationNode = mitk::LabelSetImageHelper::CreateNewSegmentationNode(referenceNode, segTemplateImage);
     }
     catch (mitk::Exception& e)
     {
       MITK_ERROR << "Exception caught: " << e.GetDescription();
       QMessageBox::warning(nullptr, "New segmentation", "Could not create a new segmentation.");
       return;
     }
 
     auto newLabelSetImage = dynamic_cast<mitk::LabelSetImage*>(newSegmentationNode->GetData());
     if (nullptr == newLabelSetImage)
     {
       // something went wrong
       return;
     }
 
     mitk::Label::Pointer newLabel = mitk::LabelSetImageHelper::CreateNewLabel(newLabelSetImage);
     newLabelSetImage->GetActiveLabelSet()->AddLabel(newLabel);
 
     if (!m_DataStorage->Exists(newSegmentationNode))
     {
       m_DataStorage->Add(newSegmentationNode, referenceNode);
     }
   }
 }
 
 void QmitkCreateMultiLabelSegmentationAction::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   m_DataStorage = dataStorage;
 }
 
 void QmitkCreateMultiLabelSegmentationAction::SetFunctionality(berry::QtViewPart*)
 {
   //not needed
 }
 
 void QmitkCreateMultiLabelSegmentationAction::SetSmoothed(bool)
 {
   //not needed
 }
 
 void QmitkCreateMultiLabelSegmentationAction::SetDecimated(bool)
 {
   //not needed
 }
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidgetControls.ui b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidgetControls.ui
index 1f2ad71121..2d8cf565c5 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidgetControls.ui
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidgetControls.ui
@@ -1,274 +1,274 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkImageMaskingWidgetControls</class>
  <widget class="QWidget" name="QmitkImageMaskingWidgetControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>179</width>
     <height>296</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="spacing">
     <number>2</number>
    </property>
    <property name="margin">
     <number>4</number>
    </property>
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="m_tbMasks">
       <attribute name="title">
        <string>Masks</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_2">
        <property name="spacing">
         <number>3</number>
        </property>
        <property name="margin">
         <number>4</number>
        </property>
        <item>
         <widget class="QmitkDataSelectionWidget" name="dataSelectionWidget" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox">
          <property name="title">
           <string>Masking Mode</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_3">
           <item>
            <widget class="QRadioButton" name="rbMaskImage">
             <property name="text">
              <string>Image Masking</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QRadioButton" name="rbMaskSurface">
             <property name="text">
              <string>Surface Masking</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QPushButton" name="btnMaskImage">
          <property name="text">
           <string>Mask</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="m_chkMakeOutputBinary">
          <property name="text">
           <string>make output binary</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="m_chkOverwriteForeground">
          <property name="text">
           <string>overwrite foreground</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="m_chkOverwriteBackground">
          <property name="text">
           <string>overwrite background</string>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <item>
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>Background Value: </string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_2">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QLineEdit" name="m_leBackgroundValue">
            <property name="minimumSize">
             <size>
              <width>50</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>50</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="text">
             <string>0.0</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_2">
          <item>
           <widget class="QLabel" name="label">
            <property name="text">
             <string>Foreground Value: </string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QLineEdit" name="m_leForegroundValue">
            <property name="minimumSize">
             <size>
              <width>50</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>50</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="text">
             <string>1.0</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="m_tbLabels">
       <attribute name="title">
        <string>Labels</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_4">
        <property name="margin">
         <number>4</number>
        </property>
        <item>
         <widget class="QmitkLabelSetWidget" name="m_LabelSetWidget" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>50</height>
           </size>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QmitkMaskStampWidget" name="m_MaskStampWidget" native="true"/>
        </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataSelectionWidget</class>
    <extends>QWidget</extends>
    <header>internal/Common/QmitkDataSelectionWidget.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkLabelSetWidget</class>
    <extends>QWidget</extends>
-   <header location="global">Qmitk/QmitkLabelSetWidget.h</header>
+   <header location="global">QmitkLabelSetWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkMaskStampWidget</class>
    <extends>QWidget</extends>
    <header>QmitkMaskStampWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.cpp
index ebf2baba70..185b773c1c 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.cpp
@@ -1,245 +1,245 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkMorphologicalOperationsWidget.h"
 #include <mitkMorphologicalOperations.h>
 #include <mitkProgressBar.h>
 #include <berryPlatform.h>
 #include <mitkIDataStorageService.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkToolManagerProvider.h>
 
 static const char* const HelpText = "Select a mask above";
 
 QmitkMorphologicalOperationsWidget::QmitkMorphologicalOperationsWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent)
   : QmitkSegmentationUtilityWidget(timeNavigationController, parent)
 {
   m_Controls.setupUi(this);
 
   m_Controls.m_DataSelectionWidget->AddDataSelection(QmitkDataSelectionWidget::MaskPredicate);
   m_Controls.m_DataSelectionWidget->SetHelpText(HelpText);
 
   mitk::DataStorage::Pointer ds = m_Controls.m_DataSelectionWidget->GetDataStorage();
   m_Controls.m_LabelSetWidget->SetDataStorage(ds);
   m_Controls.m_LabelSetWidget->setEnabled(true);
 
-  m_Controls.m_ToolSelectionBox->SetToolManager(*mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION));
+  m_Controls.m_ToolSelectionBox->SetToolManager(*mitk::ToolManagerProvider::GetInstance()->GetToolManager());
   m_Controls.m_ToolSelectionBox->SetGenerateAccelerators(true);
   m_Controls.m_ToolSelectionBox->SetToolGUIArea( m_Controls.m_ToolGUIContainer );
   m_Controls.m_ToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible );
   m_Controls.m_ToolSelectionBox->SetDisplayedToolGroups("Median Dilate Erode Open Close 'Fill Holes' 'Keep N Largest' 'Split' 'Region Selector'");
 
   connect(m_Controls.btnClosing, SIGNAL(clicked()), this, SLOT(OnClosingButtonClicked()));
   connect(m_Controls.btnOpening, SIGNAL(clicked()), this, SLOT(OnOpeningButtonClicked()));
   connect(m_Controls.btnDilatation, SIGNAL(clicked()), this, SLOT(OnDilatationButtonClicked()));
   connect(m_Controls.btnErosion, SIGNAL(clicked()), this, SLOT(OnErosionButtonClicked()));
   connect(m_Controls.btnFillHoles, SIGNAL(clicked()), this, SLOT(OnFillHolesButtonClicked()));
   connect(m_Controls.radioButtonMorphoCross, SIGNAL(clicked()), this, SLOT(OnRadioButtonsClicked()));
   connect(m_Controls.radioButtonMorphoBall, SIGNAL(clicked()), this, SLOT(OnRadioButtonsClicked()));
   connect(m_Controls.m_DataSelectionWidget, SIGNAL(SelectionChanged(unsigned int, const mitk::DataNode*)), this, SLOT(OnSelectionChanged(unsigned int, const mitk::DataNode*)));
 
   if (m_Controls.m_DataSelectionWidget->GetSelection(0).IsNotNull())
     this->OnSelectionChanged(0, m_Controls.m_DataSelectionWidget->GetSelection(0));
 }
 
 QmitkMorphologicalOperationsWidget::~QmitkMorphologicalOperationsWidget()
 {
 }
 
 void QmitkMorphologicalOperationsWidget::OnSelectionChanged(unsigned int, const mitk::DataNode*)
 {
   QmitkDataSelectionWidget* m_DataSelectionWidget = m_Controls.m_DataSelectionWidget;
   mitk::DataNode::Pointer node = m_DataSelectionWidget->GetSelection(0);
 
   if (node.IsNotNull())
   {
     m_Controls.m_DataSelectionWidget->SetHelpText("");
     this->EnableButtons(true);
   }
   else
   {
     m_Controls.m_DataSelectionWidget->SetHelpText(HelpText);
     this->EnableButtons(false);
   }
 }
 
 void QmitkMorphologicalOperationsWidget::EnableButtons(bool enable)
 {
   m_Controls.btnClosing->setEnabled(enable);
   m_Controls.btnDilatation->setEnabled(enable);
   m_Controls.btnErosion->setEnabled(enable);
   m_Controls.btnFillHoles->setEnabled(enable);
   m_Controls.btnOpening->setEnabled(enable);
 }
 
 void QmitkMorphologicalOperationsWidget::OnRadioButtonsClicked()
 {
   bool enable = m_Controls.radioButtonMorphoBall->isChecked();
 
   m_Controls.sliderMorphFactor->setEnabled(enable);
   m_Controls.spinBoxMorphFactor->setEnabled(enable);
 }
 
 void QmitkMorphologicalOperationsWidget::OnClosingButtonClicked()
 {
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QmitkDataSelectionWidget* m_DataSelectionWidget = m_Controls.m_DataSelectionWidget;
   mitk::DataNode::Pointer node = m_DataSelectionWidget->GetSelection(0);
   mitk::Image::Pointer image = static_cast<mitk::Image*>(node->GetData());
   bool ball = m_Controls.radioButtonMorphoBall->isChecked();
 
   mitk::MorphologicalOperations::StructuralElementType structuralElement = ball
     ? mitk::MorphologicalOperations::Ball
     : mitk::MorphologicalOperations::Cross;
 
   try
   {
     mitk::MorphologicalOperations::Closing(image, m_Controls.spinBoxMorphFactor->value(), structuralElement);
   }
   catch (const itk::ExceptionObject& exception)
   {
     MITK_WARN << "Exception caught: " << exception.GetDescription();
 
     QApplication::restoreOverrideCursor();
     return;
   }
 
   node->SetData(image);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkMorphologicalOperationsWidget::OnOpeningButtonClicked()
 {
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QmitkDataSelectionWidget* m_DataSelectionWidget = m_Controls.m_DataSelectionWidget;
   mitk::DataNode::Pointer node = m_DataSelectionWidget->GetSelection(0);
   mitk::Image::Pointer image = static_cast<mitk::Image*>(node->GetData());
   bool ball = m_Controls.radioButtonMorphoBall->isChecked();
 
   mitk::MorphologicalOperations::StructuralElementType structuralElement = ball
     ? mitk::MorphologicalOperations::Ball
     : mitk::MorphologicalOperations::Cross;
 
   try
   {
      mitk::MorphologicalOperations::Opening(image, m_Controls.spinBoxMorphFactor->value(), structuralElement);
   }
   catch (const itk::ExceptionObject& exception)
   {
      MITK_WARN << "Exception caught: " << exception.GetDescription();
 
      QApplication::restoreOverrideCursor();
      return;
   }
 
   node->SetData(image);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkMorphologicalOperationsWidget::OnDilatationButtonClicked()
 {
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QmitkDataSelectionWidget* m_DataSelectionWidget = m_Controls.m_DataSelectionWidget;
   mitk::DataNode::Pointer node = m_DataSelectionWidget->GetSelection(0);
   mitk::Image::Pointer image = static_cast<mitk::Image*>(node->GetData());
   bool ball = m_Controls.radioButtonMorphoBall->isChecked();
 
   mitk::MorphologicalOperations::StructuralElementType structuralElement = ball
     ? mitk::MorphologicalOperations::Ball
     : mitk::MorphologicalOperations::Cross;
 
   try
   {
     mitk::MorphologicalOperations::Dilate(image, m_Controls.spinBoxMorphFactor->value(), structuralElement);
   }
   catch (const itk::ExceptionObject& exception)
   {
     MITK_WARN << "Exception caught: " << exception.GetDescription();
 
     QApplication::restoreOverrideCursor();
     return;
   }
 
   node->SetData(image);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkMorphologicalOperationsWidget::OnErosionButtonClicked()
 {
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QmitkDataSelectionWidget* m_DataSelectionWidget = m_Controls.m_DataSelectionWidget;
   mitk::DataNode::Pointer node = m_DataSelectionWidget->GetSelection(0);
   mitk::Image::Pointer image = static_cast<mitk::Image*>(node->GetData());
   bool ball = m_Controls.radioButtonMorphoBall->isChecked();
 
   mitk::MorphologicalOperations::StructuralElementType structuralElement = ball
     ? mitk::MorphologicalOperations::Ball
     : mitk::MorphologicalOperations::Cross;
 
   try
   {
     mitk::MorphologicalOperations::Erode(image, m_Controls.spinBoxMorphFactor->value(), structuralElement);
   }
   catch (const itk::ExceptionObject& exception)
   {
     MITK_WARN << "Exception caught: " << exception.GetDescription();
 
     QApplication::restoreOverrideCursor();
     return;
  }
 
   node->SetData(image);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkMorphologicalOperationsWidget::OnFillHolesButtonClicked()
 {
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QmitkDataSelectionWidget* m_DataSelectionWidget = m_Controls.m_DataSelectionWidget;
   mitk::DataNode::Pointer node = m_DataSelectionWidget->GetSelection(0);
   mitk::Image::Pointer image = static_cast<mitk::Image*>(node->GetData());
 
   try
   {
     mitk::MorphologicalOperations::FillHoles(image);
   }
   catch (const itk::ExceptionObject& exception)
   {
     MITK_WARN << "Exception caught: " << exception.GetDescription();
 
     QApplication::restoreOverrideCursor();
     return;
   }
 
   node->SetData(image);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QApplication::restoreOverrideCursor();
 }
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidgetControls.ui b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidgetControls.ui
index 976fffbdc3..0e8a3c92b5 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidgetControls.ui
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidgetControls.ui
@@ -1,427 +1,427 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkMorphologicalOperationsWidgetControls</class>
  <widget class="QWidget" name="QmitkMorphologicalOperationsWidgetControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>155</width>
     <height>414</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="m_tbMasks">
       <attribute name="title">
        <string>Masks</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_2">
        <property name="spacing">
         <number>3</number>
        </property>
        <property name="margin">
         <number>4</number>
        </property>
        <item>
         <widget class="QmitkDataSelectionWidget" name="m_DataSelectionWidget" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox">
          <property name="title">
           <string>Structuring Element</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_3">
           <item>
            <widget class="QRadioButton" name="radioButtonMorphoBall">
             <property name="text">
              <string>Ball</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QRadioButton" name="radioButtonMorphoCross">
             <property name="text">
              <string>Cross</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <item>
           <widget class="QLabel" name="label">
            <property name="text">
             <string>Radius</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QSlider" name="sliderMorphFactor">
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>20</number>
            </property>
            <property name="pageStep">
             <number>1</number>
            </property>
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QSpinBox" name="spinBoxMorphFactor">
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>20</number>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QGridLayout" name="gridLayout">
          <item row="0" column="0">
           <widget class="QToolButton" name="btnDilatation">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Dilatation</string>
            </property>
            <property name="icon">
             <iconset resource="../../../../resources/MorphologicalOperationsWidget.qrc">
              <normaloff>:/SegmentationUtilities/MorphologicalOperations/Dilate_48x48.png</normaloff>:/SegmentationUtilities/MorphologicalOperations/Dilate_48x48.png</iconset>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="toolButtonStyle">
             <enum>Qt::ToolButtonTextUnderIcon</enum>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QToolButton" name="btnFillHoles">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="toolTip">
             <string>Globally fills holes in segmentation (radius not required)</string>
            </property>
            <property name="text">
             <string>Fill Holes</string>
            </property>
            <property name="icon">
             <iconset resource="../../../../resources/MorphologicalOperationsWidget.qrc">
              <normaloff>:/SegmentationUtilities/MorphologicalOperations/FillHoles_48x48.png</normaloff>:/SegmentationUtilities/MorphologicalOperations/FillHoles_48x48.png</iconset>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="toolButtonStyle">
             <enum>Qt::ToolButtonTextUnderIcon</enum>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QToolButton" name="btnErosion">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Erosion</string>
            </property>
            <property name="icon">
             <iconset resource="../../../../resources/MorphologicalOperationsWidget.qrc">
              <normaloff>:/SegmentationUtilities/MorphologicalOperations/Erode_48x48.png</normaloff>:/SegmentationUtilities/MorphologicalOperations/Erode_48x48.png</iconset>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="toolButtonStyle">
             <enum>Qt::ToolButtonTextUnderIcon</enum>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QToolButton" name="btnClosing">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Closing</string>
            </property>
            <property name="icon">
             <iconset resource="../../../../resources/MorphologicalOperationsWidget.qrc">
              <normaloff>:/SegmentationUtilities/MorphologicalOperations/Closing_48x48.png</normaloff>:/SegmentationUtilities/MorphologicalOperations/Closing_48x48.png</iconset>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="toolButtonStyle">
             <enum>Qt::ToolButtonTextUnderIcon</enum>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QToolButton" name="btnOpening">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Opening</string>
            </property>
            <property name="icon">
             <iconset resource="../../../../resources/MorphologicalOperationsWidget.qrc">
              <normaloff>:/SegmentationUtilities/MorphologicalOperations/Opening_48x48.png</normaloff>:/SegmentationUtilities/MorphologicalOperations/Opening_48x48.png</iconset>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="toolButtonStyle">
             <enum>Qt::ToolButtonTextUnderIcon</enum>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="m_tbLabels">
       <attribute name="title">
        <string>Labels</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_4">
        <property name="spacing">
         <number>3</number>
        </property>
        <property name="margin">
         <number>4</number>
        </property>
        <item>
         <widget class="QmitkLabelSetWidget" name="m_LabelSetWidget" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>50</height>
           </size>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QmitkToolGUIArea" name="m_ToolGUIContainer" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>15</width>
            <height>0</height>
           </size>
          </property>
          <property name="font">
           <font>
            <weight>50</weight>
            <bold>false</bold>
           </font>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QmitkToolSelectionBox" name="m_ToolSelectionBox" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="MinimumExpanding">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>15</height>
           </size>
          </property>
          <property name="font">
           <font>
            <weight>50</weight>
            <bold>false</bold>
           </font>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataSelectionWidget</class>
    <extends>QWidget</extends>
    <header>internal/Common/QmitkDataSelectionWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkToolSelectionBox</class>
    <extends>QWidget</extends>
    <header location="global">QmitkToolSelectionBox.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkToolGUIArea</class>
    <extends>QWidget</extends>
    <header location="global">QmitkToolGUIArea.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkLabelSetWidget</class>
    <extends>QWidget</extends>
-   <header location="global">Qmitk/QmitkLabelSetWidget.h</header>
+   <header location="global">QmitkLabelSetWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="../../../../resources/MorphologicalOperationsWidget.qrc"/>
  </resources>
  <connections>
   <connection>
    <sender>sliderMorphFactor</sender>
    <signal>valueChanged(int)</signal>
    <receiver>spinBoxMorphFactor</receiver>
    <slot>setValue(int)</slot>
    <hints>
     <hint type="sourcelabel">
      <x>240</x>
      <y>27</y>
     </hint>
     <hint type="destinationlabel">
      <x>766</x>
      <y>36</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>spinBoxMorphFactor</sender>
    <signal>valueChanged(int)</signal>
    <receiver>sliderMorphFactor</receiver>
    <slot>setValue(int)</slot>
    <hints>
     <hint type="sourcelabel">
      <x>784</x>
      <y>38</y>
     </hint>
     <hint type="destinationlabel">
      <x>657</x>
      <y>38</y>
     </hint>
    </hints>
   </connection>
  </connections>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidgetControls.ui b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidgetControls.ui
index 511fcc381f..52b7fc86e4 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidgetControls.ui
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidgetControls.ui
@@ -1,252 +1,252 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkSurfaceToImageWidgetControls</class>
  <widget class="QWidget" name="QmitkSurfaceToImageWidgetControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>179</width>
     <height>183</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="spacing">
     <number>3</number>
    </property>
    <property name="margin">
     <number>4</number>
    </property>
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="m_tbMasks">
       <attribute name="title">
        <string>Masks</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_2">
        <property name="spacing">
         <number>3</number>
        </property>
        <property name="margin">
         <number>4</number>
        </property>
        <item>
         <widget class="QmitkDataSelectionWidget" name="m_DataSelectionWidget" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="m_chkMakeOutputBinary">
          <property name="text">
           <string>make output binary</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="m_chkOverwriteBackground">
          <property name="text">
           <string>overwrite background</string>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <item>
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>Background Value: </string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_2">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QLineEdit" name="m_leBackgroundValue">
            <property name="minimumSize">
             <size>
              <width>50</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>50</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="text">
             <string>0.0</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_2">
          <item>
           <widget class="QLabel" name="label">
            <property name="text">
             <string>Foreground Value: </string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QLineEdit" name="m_leForegroundValue">
            <property name="minimumSize">
             <size>
              <width>50</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>50</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="text">
             <string>1.0</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QPushButton" name="btnSurface2Image">
          <property name="text">
           <string>Convert</string>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="m_tbLabels">
       <attribute name="title">
        <string>Labels</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_3">
        <property name="spacing">
         <number>2</number>
        </property>
        <property name="margin">
         <number>2</number>
        </property>
        <item>
         <widget class="QmitkLabelSetWidget" name="m_LabelSetWidget" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>50</height>
           </size>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QmitkSurfaceStampWidget" name="m_SurfaceStampWidget" native="true">
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>20</height>
           </size>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataSelectionWidget</class>
    <extends>QWidget</extends>
    <header>internal/Common/QmitkDataSelectionWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkLabelSetWidget</class>
    <extends>QWidget</extends>
-   <header location="global">Qmitk/QmitkLabelSetWidget.h</header>
+   <header location="global">QmitkLabelSetWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkSurfaceStampWidget</class>
    <extends>QWidget</extends>
    <header>QmitkSurfaceStampWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.concentration.mri/src/internal/ConcentrationCurveConverterView.h b/Plugins/org.mitk.gui.qt.pharmacokinetics.concentration.mri/src/internal/ConcentrationCurveConverterView.h
index 24bc782d46..c34767cb4a 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.concentration.mri/src/internal/ConcentrationCurveConverterView.h
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.concentration.mri/src/internal/ConcentrationCurveConverterView.h
@@ -1,104 +1,98 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef ConcentrationCurveConverterView_h
 #define ConcentrationCurveConverterView_h
 
 #include <QString>
 
 #include <QmitkAbstractView.h>
 #include "ui_ConcentrationCurveConverterViewControls.h"
 
 #include <mitkImage.h>
 
-
 /*!
  *	@brief Test Plugin for SUV calculations of PET images
  */
 class ConcentrationCurveConverterView : public QmitkAbstractView
 {
 	Q_OBJECT
 
 public:
 //    typedef itk::Image<unsigned short,3> ImageType;
     typedef itk::Image<double,3> ConvertedImageType;
 
 
 	/*! @brief The view's unique ID - required by MITK */
 	static const std::string VIEW_ID;
 
   ConcentrationCurveConverterView();
 
 protected slots:
 
 	/*!
 	 *	@brief	Is triggered of the update button is clicked and the selected node should get the (new) iso level set.
 	 */
     void OnConvertToConcentrationButtonClicked();
     void OnSettingChanged();
     bool CheckSettings() const;
 
-
-
 protected:
 
 	// Overridden base class functions
 
 	/*!
 	 *	@brief					Sets up the UI controls and connects the slots and signals. Gets
 	 *							called by the framework to create the GUI at the right time.
 	 *	@param[in,out] parent	The parent QWidget, as this class itself is not a QWidget
 	 *							subclass.
 	 */
 	void CreateQtPartControl(QWidget* parent) override;
 
 	/*!
 	 *	@brief	Sets the focus to the plot curve button. Gets called by the framework to set the
 	 *			focus on the right widget.
 	 */
 	void SetFocus() override;
 
   bool CheckBaselineSelectionSettings() const;
 
-    /*! Helper method that adds an concentration image as child node to the current m_selectedNode and returns this new child node.*/
-    mitk::DataNode::Pointer AddConcentrationImage(mitk::Image* image, std::string nodeName) const;
-
+  /*! Helper method that adds an concentration image as child node to the current m_selectedNode and returns this new child node.*/
+  mitk::DataNode::Pointer AddConcentrationImage(mitk::Image* image, std::string nodeName) const;
 
-  /*! \brief called by QmitkFunctionality when DataManager's selection has changed
-  */
   void OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>/*nodes*/);
 
 	// Variables
 
 	/*! @brief The view's UI controls */
     Ui::ConcentrationCurveConverterViewControls m_Controls;
 
     mitk::DataNode::Pointer m_selectedNode;
     mitk::Image::Pointer m_selectedImage;
     mitk::DataNode::Pointer m_selectedBaselineNode;
     mitk::Image::Pointer m_selectedBaselineImage;
 
 private:
 
     /**Converts the selected image to a concentration image based on the given gui settings.*/
     mitk::Image::Pointer Convert4DConcentrationImage(mitk::Image::Pointer inputImage);
     mitk::Image::Pointer Convert3DConcentrationImage(mitk::Image::Pointer inputImage, mitk::Image::Pointer baselineImage);
 
     mitk::Image::Pointer ConvertT2ConcentrationImgage(mitk::Image::Pointer inputImage);
 
     mitk::NodePredicateBase::Pointer m_IsNoMaskImagePredicate;
     mitk::NodePredicateBase::Pointer m_IsMaskPredicate;
     mitk::NodePredicateBase::Pointer m_isValidPDWImagePredicate;
     mitk::NodePredicateBase::Pointer m_isValidTimeSeriesImagePredicate;
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.curvedescriptor/src/internal/PerfusionCurveDescriptionParameterView.h b/Plugins/org.mitk.gui.qt.pharmacokinetics.curvedescriptor/src/internal/PerfusionCurveDescriptionParameterView.h
index 0e91491a8c..7695df513a 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.curvedescriptor/src/internal/PerfusionCurveDescriptionParameterView.h
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.curvedescriptor/src/internal/PerfusionCurveDescriptionParameterView.h
@@ -1,106 +1,102 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef PerfusionCurveDescriptionParameterView_h
 #define PerfusionCurveDescriptionParameterView_h
 
 #include <QString>
 
 #include <QmitkAbstractView.h>
 #include "ui_PerfusionCurveDescriptionParameterViewControls.h"
 #include "mitkCurveDescriptionParameterBase.h"
 #include <QmitkDescriptionParameterBackgroundJob.h>
 
 #include <mitkImage.h>
 
 namespace mitk
 {
   class CurveParameterFunctor;
 }
 
 /*!
  *	@brief Test Plugin for SUV calculations of PET images
  */
 class PerfusionCurveDescriptionParameterView : public QmitkAbstractView
 {
 	Q_OBJECT
 
 public:
 
     typedef mitk::CurveDescriptionParameterBase::CurveDescriptionParameterNameType ParameterNameType;
 
 	/*! @brief The view's unique ID - required by MITK */
 	static const std::string VIEW_ID;
 
   PerfusionCurveDescriptionParameterView();
 
 protected slots:
 
     void InitParameterList();
 
     void OnJobFinished();
     void OnJobError(QString err);
     void OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType results,
       const DescriptionParameterBackgroundJob* pJob);
     void OnJobProgress(double progress);
     void OnJobStatusChanged(QString info);
 
 	/*!
 	 *	@brief	Is triggered of the update button is clicked and the selected node should get the (new) iso level set.
 	 */
     void OnCalculateParametersButtonClicked();
 
 protected:
 
 	// Overridden base class functions
 
 	/*!
 	 *	@brief					Sets up the UI controls and connects the slots and signals. Gets
 	 *							called by the framework to create the GUI at the right time.
 	 *	@param[in,out] parent	The parent QWidget, as this class itself is not a QWidget
 	 *							subclass.
 	 */
 	void CreateQtPartControl(QWidget* parent) override;
 
 	/*!
 	 *	@brief	Sets the focus to the plot curve button. Gets called by the framework to set the
 	 *			focus on the right widget.
 	 */
 	void SetFocus() override;
 
   /** Configures the passed functor according to the selected image and parameters*/
   void ConfigureFunctor(mitk::CurveParameterFunctor* functor) const;
 
-  /*! \brief called by QmitkFunctionality when DataManager's selection has changed
-  */
   void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
     const QList<mitk::DataNode::Pointer>& nodes) override;
 
 	// Variables
 
 	/*! @brief The view's UI controls */
     Ui::PerfusionCurveDescriptionParameterViewControls m_Controls;
     mitk::DataNode::Pointer m_selectedNode;
 
 private:
 
-
-
     typedef std::map<ParameterNameType, mitk::CurveDescriptionParameterBase::Pointer > ParameterMapType;
 
     ParameterMapType m_ParameterMap;
 
     mitk::Image::Pointer m_selectedImage;
     mitk::Image::Pointer m_selectedMask;
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.h b/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.h
index f6738bd796..7c65eca0a4 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.h
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.h
@@ -1,214 +1,206 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MRPerfusionView_h
 #define MRPerfusionView_h
 
 #include <QString>
 
 #include "QmitkAbstractView.h"
 
 #include "itkCommand.h"
 
 #include "ui_MRPerfusionViewControls.h"
 #include "mitkModelBase.h"
 #include "QmitkParameterFitBackgroundJob.h"
 #include "mitkModelFitResultHelper.h"
 #include "mitkModelFactoryBase.h"
 #include "mitkLevenbergMarquardtModelFitFunctor.h"
 #include "mitkSimpleBarrierConstraintChecker.h"
 #include "mitkAIFBasedModelBase.h"
 
-
-
 /*!
 *	@brief Test Plugin for SUV calculations of PET images
 */
 class MRPerfusionView : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   /*! @brief The view's unique ID - required by MITK */
   static const std::string VIEW_ID;
 
   MRPerfusionView();
 
 protected slots:
 
   void OnModellingButtonClicked();
 
   void OnJobFinished();
   void OnJobError(QString err);
   void OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType results,
                                 const ParameterFitBackgroundJob* pJob);
   void OnJobProgress(double progress);
   void OnJobStatusChanged(QString info);
 
   void OnModellSet(int);
   void LoadAIFfromFile();
 
   /**Sets visibility and enabled state of the GUI depending on the settings and workflow state.*/
   void UpdateGUIControls();
 
 protected:
   typedef QList<mitk::DataNode*> SelectedDataNodeVectorType;
 
   // Overridden base class functions
 
   /*!
   *	@brief					Sets up the UI controls and connects the slots and signals. Gets
   *							called by the framework to create the GUI at the right time.
   *	@param[in,out] parent	The parent QWidget, as this class itself is not a QWidget
   *							subclass.
   */
   void CreateQtPartControl(QWidget* parent) override;
 
   /*!
   *	@brief	Sets the focus to the plot curve button. Gets called by the framework to set the
   *			focus on the right widget.
   */
   void SetFocus() override;
 
   /*! @brief Generates a configured fit generator and the corresponding modelinfo for a descriptive brix model with pixel based strategy.
   * @remark add GenerateFunction for each model in the Combo box*/
   void GenerateDescriptiveBrixModel_PixelBased(mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
       mitk::ParameterFitImageGeneratorBase::Pointer& generator);
   void GenerateDescriptiveBrixModel_ROIBased(mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
       mitk::ParameterFitImageGeneratorBase::Pointer& generator);
 
   template <typename TParameterizer>
   void GenerateLinearModelFit_PixelBased(mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
       mitk::ParameterFitImageGeneratorBase::Pointer& generator);
   template <typename TParameterizer>
   void GenerateLinearModelFit_ROIBased(mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
       mitk::ParameterFitImageGeneratorBase::Pointer& generator);
 
 
   template <typename TParameterizer>
   void GenerateAIFbasedModelFit_ROIBased(mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
                                  mitk::ParameterFitImageGeneratorBase::Pointer& generator);
   template <typename TParameterizer>
   void GenerateAIFbasedModelFit_PixelBased(mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
                                    mitk::ParameterFitImageGeneratorBase::Pointer& generator);
 
   /** Helper function that configures the initial parameter strategy of a parameterizer
    according to the settings of the GUI.*/
   void ConfigureInitialParametersOfParameterizer(mitk::ModelParameterizerBase* parameterizer) const;
 
   /*! Starts the fitting job with the passed generator and session info*/
   void DoFit(const mitk::modelFit::ModelFitInfo* fitSession,
              mitk::ParameterFitImageGeneratorBase* generator);
 
   /**Checks if the settings in the GUI are valid for the chosen model.*/
   bool CheckModelSettings() const;
 
   bool CheckBaselineSelectionSettings() const;
 
   void InitModelComboBox() const;
 
-
-
-
   /*! Helper method that generates a node for the passed concentration image.*/
   mitk::DataNode::Pointer GenerateConcentrationNode(mitk::Image* image, const std::string& nodeName) const;
 
-    /*! \brief called by QmitkFunctionality when DataManager's selection has changed
-  */
-
   void OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/);
 
   /*! @brief The view's UI controls */
   Ui::MRPerfusionViewControls m_Controls;
 
   /* Nodes selected by user/ui for the fit */
   mitk::DataNode::Pointer m_selectedNode;
   mitk::DataNode::Pointer m_selectedMaskNode;
   mitk::DataNode::Pointer m_selectedAIFMaskNode;
   mitk::DataNode::Pointer m_selectedAIFImageNode;
 
   /* Images selected by user/ui for the fit */
   mitk::Image::Pointer m_selectedImage;
   mitk::Image::Pointer m_selectedMask;
   mitk::Image::Pointer m_selectedAIFMask;
   mitk::Image::Pointer m_selectedAIFImage;
 
   mitk::ModelFactoryBase::Pointer m_selectedModelFactory;
 
   mitk::SimpleBarrierConstraintChecker::Pointer m_modelConstraints;
 
 private:
   bool IsTurboFlashSequenceFlag() const;
 
   bool m_FittingInProgress;
 
   typedef std::vector<mitk::ModelFactoryBase::Pointer> ModelFactoryStackType;
   ModelFactoryStackType m_FactoryStack;
 
   /**Converts the selected image to a concentration image based on the given gui settings.
    AIFMode controls if the concentration image for the fit input or the AIF will be converted.*/
   mitk::Image::Pointer ConvertConcentrationImage(bool AIFMode);
 
   /**Helper function that (depending on the gui settings) prepares m_inputNode and m_inputImage.
    Either by directly pass back the selected image/node or the newly generated concentration image/node.
    After calling this method  m_inputImage are always what should be used as input image
    for the fitting.*/
   void PrepareConcentrationImage();
 
   /**Helper function that (depending on the gui settings) prepares m_inputAIFNode and m_inputAIFImage.
   Either by directly pass back the selected image/node or the newly generated concentration image/node.
   After calling this method m_inputAIFImage are always what should be used as AIF image
   for the fitting.*/
   void PrepareAIFConcentrationImage();
 
   /**Helper function that (depending on the gui settings) generates and passes back the AIF and its time grid
    that should be used for fitting.
    @remark the parameters aif and aifTimeGrid will be initialized accordingly if the method returns.*/
   void GetAIF(mitk::AIFBasedModelBase::AterialInputFunctionType& aif,
               mitk::AIFBasedModelBase::AterialInputFunctionType& aifTimeGrid);
 
   /**Helper function that generates a default fitting functor
    * default is a levenberg marquart based optimizer with all scales set to 1.0.
    * Constraint setter will be set based on the gui setting and a evaluation parameter
    * "sum of squared differences" will always be set.*/
   mitk::ModelFitFunctorBase::Pointer CreateDefaultFitFunctor(const mitk::ModelParameterizerBase*
       parameterizer) const;
 
   /**Returns the default fit name, derived from the current GUI settings.*/
   std::string GetDefaultFitName() const;
   /**Returns the current set name of the fit (either default name or use defined name).*/
   std::string GetFitName() const;
 
   std::vector<double> AIFinputGrid;
   std::vector<double> AIFinputFunction;
 
   mitk::NodePredicateBase::Pointer m_IsNoMaskImagePredicate;
   mitk::NodePredicateBase::Pointer m_IsMaskPredicate;
   mitk::NodePredicateBase::Pointer m_isValidPDWImagePredicate;
   mitk::NodePredicateBase::Pointer m_isValidTimeSeriesImagePredicate;
 
   /* Node used for the fit (my be the selected image
   or converted ones (depending on the ui settings */
   mitk::DataNode::Pointer m_inputNode;
   mitk::DataNode::Pointer m_inputAIFNode;
   bool m_HasGeneratedNewInput;
   bool m_HasGeneratedNewInputAIF;
 
   /* Image used for the fit (my be the selected image
   or converted ones (depending on the ui settings */
   mitk::Image::Pointer m_inputImage;
   mitk::Image::Pointer m_inputAIFImage;
 
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.pet/src/internal/PETDynamicView.h b/Plugins/org.mitk.gui.qt.pharmacokinetics.pet/src/internal/PETDynamicView.h
index 78a4e5f33b..80bace9897 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.pet/src/internal/PETDynamicView.h
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.pet/src/internal/PETDynamicView.h
@@ -1,172 +1,168 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef PETDynamicView_h
 #define PETDynamicView_h
 
 #include <QString>
 
 #include "QmitkAbstractView.h"
 
 #include "itkCommand.h"
 
 #include "ui_PETDynamicViewControls.h"
 #include "mitkModelBase.h"
 #include "QmitkParameterFitBackgroundJob.h"
 #include "mitkModelFitResultHelper.h"
 #include "mitkModelFactoryBase.h"
 #include "mitkLevenbergMarquardtModelFitFunctor.h"
 #include "mitkSimpleBarrierConstraintChecker.h"
 #include "mitkAIFBasedModelBase.h"
 
 /*!
 *	@brief Test Plugin for SUV calculations of PET images
 */
 class PETDynamicView : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   /*! @brief The view's unique ID - required by MITK */
   static const std::string VIEW_ID;
 
   PETDynamicView();
 
 protected slots:
 
-
   void OnModellingButtonClicked();
 
   void OnJobFinished();
   void OnJobError(QString err);
   void OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType results,
                                 const ParameterFitBackgroundJob* pJob);
   void OnJobProgress(double progress);
   void OnJobStatusChanged(QString info);
 
   void OnModellSet(int);
   void LoadAIFfromFile();
 
 //  void OnModelSettingChanged();
   void UpdateGUIControls();
 
 protected:
   typedef QList<mitk::DataNode*> SelectedDataNodeVectorType;
 
   // Overridden base class functions
 
   /*!
   *	@brief					Sets up the UI controls and connects the slots and signals. Gets
   *							called by the framework to create the GUI at the right time.
   *	@param[in,out] parent	The parent QWidget, as this class itself is not a QWidget
   *							subclass.
   */
   void CreateQtPartControl(QWidget* parent) override;
 
   /*!
   *	@brief	Sets the focus to the plot curve button. Gets called by the framework to set the
   *			focus on the right widget.
   */
   void SetFocus() override;
 
   /*! @brief Generates a configured fit generator and the corresponding modelinfo for a descriptive brix model with pixel based strategy.
   * @remark add GenerateFunction for each model in the Combo box*/
 
   template <typename TParameterizer>
   void GenerateModelFit_ROIBased(mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
                                  mitk::ParameterFitImageGeneratorBase::Pointer& generator);
 
   template <typename TParameterizer>
   void GenerateModelFit_PixelBased(mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
                                    mitk::ParameterFitImageGeneratorBase::Pointer& generator);
 
   /** Helper function that configures the initial parameter strategy of a parameterizer
    according to the settings of the GUI.*/
   void ConfigureInitialParametersOfParameterizer(mitk::ModelParameterizerBase* parameterizer) const;
 
   /*! Starts the fitting job with the passed generator and session info*/
   void DoFit(const mitk::modelFit::ModelFitInfo* fitSession,
              mitk::ParameterFitImageGeneratorBase* generator);
 
   bool CheckModelSettings() const;
 
   void InitModelComboBox() const;
 
-  /*! \brief called by QmitkFunctionality when DataManager's selection has changed
-  */
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
                                   const QList<mitk::DataNode::Pointer>& selectedNodes) override;
 
 
   /*! @brief The view's UI controls */
   Ui::PETDynamicViewControls m_Controls;
 
   mitk::DataNode::Pointer m_selectedNode;
   mitk::DataNode::Pointer m_selectedMaskNode;
   mitk::DataNode::Pointer m_selectedAIFMaskNode;
   mitk::DataNode::Pointer m_selectedAIFImageNode;
 
   mitk::Image::Pointer m_selectedImage;
   mitk::Image::Pointer m_selectedMask;
   mitk::Image::Pointer m_selectedAIFMask;
   mitk::Image::Pointer m_selectedAIFImage;
 
   /* Node used for the fit (my be the selected image
   or converted ones (depending on the ui settings */
   mitk::DataNode::Pointer m_inputNode;
   mitk::DataNode::Pointer m_inputAIFNode;
 
   /* Image used for the fit (my be the selected image
    or converted ones (depending on the ui settings */
   mitk::Image::Pointer m_inputImage;
   mitk::Image::Pointer m_inputAIFImage;
 
   mitk::ModelFactoryBase::Pointer m_selectedModelFactory;
 
   mitk::SimpleBarrierConstraintChecker::Pointer m_modelConstraints;
 
-
 private:
   bool m_FittingInProgress;
 
 
   typedef std::vector<mitk::ModelFactoryBase::Pointer> ModelFactoryStackType;
   ModelFactoryStackType m_FactoryStack;
 
   /**Helper function that (depending on the gui settings) generates and passes back the AIF and its time grid
    that should be used for fitting.
    @remark the parameters aif and aifTimeGrid will be initialized accordingly if the method returns.*/
   void GetAIF(mitk::AIFBasedModelBase::AterialInputFunctionType& aif,
               mitk::AIFBasedModelBase::AterialInputFunctionType& aifTimeGrid);
 
   /**Helper function that generates a default fitting functor
    * default is a levenberg marquart based optimizer with all scales set to 1.0.
    * Constraint setter will be set based on the gui setting and a evaluation parameter
    * "sum of squared differences" will always be set.*/
   mitk::ModelFitFunctorBase::Pointer CreateDefaultFitFunctor(const mitk::ModelParameterizerBase*
       parameterizer) const;
 
   /**Returns the default fit name, derived from the current GUI settings.*/
   std::string GetDefaultFitName() const;
   /**Returns the current set name of the fit (either default name or use defined name).*/
   std::string GetFitName() const;
 
   std::vector<double> AIFinputGrid;
   std::vector<double> AIFinputFunction;
 
   mitk::NodePredicateBase::Pointer m_IsNoMaskImagePredicate;
   mitk::NodePredicateBase::Pointer m_IsMaskPredicate;
 
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.simulation/src/internal/PerfusionDataSimulationView.h b/Plugins/org.mitk.gui.qt.pharmacokinetics.simulation/src/internal/PerfusionDataSimulationView.h
index 54ec965992..7956d413f1 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.simulation/src/internal/PerfusionDataSimulationView.h
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.simulation/src/internal/PerfusionDataSimulationView.h
@@ -1,129 +1,114 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef PerfusionDataSimulationView_h
 #define PerfusionDataSimulationView_h
 
 #include <QString>
 
 #include <QmitkAbstractView.h>
 #include "ui_PerfusionDataSimulationViewControls.h"
 #include "mitkModelBase.h"
 #include <mitkModelFactoryBase.h>
 
 #include "itkArray.h"
 #include "mitkImage.h"
 
-
 #include <mitkImage.h>
 
-
 /*!
  *	@brief Test Plugin for SUV calculations of PET images
  */
 class PerfusionDataSimulationView : public QmitkAbstractView
 {
 	Q_OBJECT
 
 public:
 
 	/*! @brief The view's unique ID - required by MITK */
 	static const std::string VIEW_ID;
 
   PerfusionDataSimulationView();
 
 protected slots:
 
 	/*!
 	 *	@brief	Is triggered of the update button is clicked and the selected node should get the (new) iso level set.
 	 */
     void OnGenerateDataButtonClicked();
     void LoadAIFFile();
     void OnModellSet(int);
 
     void OnSimulationConfigurationChanged();
 
     void UpdateDataSelection();
 
-
 protected:
     typedef std::map<std::string, mitk::Image::Pointer> ParameterMapType;
 
 	// Overridden base class functions
 
 	/*!
 	 *	@brief					Sets up the UI controls and connects the slots and signals. Gets
 	 *							called by the framework to create the GUI at the right time.
 	 *	@param[in,out] parent	The parent QWidget, as this class itself is not a QWidget
 	 *							subclass.
 	 */
 	void CreateQtPartControl(QWidget* parent) override;
 
 	/*!
 	 *	@brief	Sets the focus to the plot curve button. Gets called by the framework to set the
 	 *			focus on the right widget.
 	 */
 	void SetFocus() override;
 
-
-    void InitModelComboBox() const;
-
+  void InitModelComboBox() const;
 
   mitk::Image::Pointer Generate2CXModelData();
   mitk::Image::Pointer GenerateNumeric2CXModelData();
   mitk::Image::Pointer GenerateETModelData();
   void FillParameterMap2CXM();
   void FillParameterMapNumeric2CXM();
   void FillParameterMapETM();
 
-
-
   ///////////////////// dynamic PET Models///////////////
   mitk::Image::Pointer Generate2TCModelData();
   mitk::Image::Pointer Generate1TCModelData();
   void FillParameterMap2TCM();
   void FillParameterMap1TCM();
 
 
   bool CheckModelSettings();
 
-
-  /*! \brief called by QmitkFunctionality when DataManager's selection has changed
-  */
-//  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
-//                                  const QList<mitk::DataNode::Pointer>& selectedNodes);
-
-
 	// Variables
 
 	/*! @brief The view's UI controls */
     Ui::PerfusionDataSimulationViewControls m_Controls;
     mitk::DataNode::Pointer m_selectedNode;
 
     ParameterMapType m_ParameterImageMap;
     itk::Array<double> m_AterialInputFunction;
     itk::Array<double> m_TimeGrid;
 
     mitk::ModelFactoryBase::Pointer m_selectedModelFactory;
 
-
 private:
 
     typedef std::vector<mitk::ModelFactoryBase::Pointer> ModelFactoryStackType;
     ModelFactoryStackType m_FactoryStack;
     mitk::NodePredicateBase::Pointer m_IsNotABinaryImagePredicate;
 
     double m_CNR, m_MaxConcentration, m_Sigma;
 
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/src/internal/PointSetInteractionMultispectrum.h b/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/src/internal/PointSetInteractionMultispectrum.h
index 3cc3aca58e..e43934a39d 100644
--- a/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/src/internal/PointSetInteractionMultispectrum.h
+++ b/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/src/internal/PointSetInteractionMultispectrum.h
@@ -1,90 +1,79 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
-
 #ifndef PointSetInteractionMultispectrum_h
 #define PointSetInteractionMultispectrum_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 #include <qwt_plot.h>
 #include "ui_PointSetInteractionMultispectrumControls.h"
 
 /////////////added from the regiongrowing plugin//////////////
 #include "mitkPointSet.h"                              ///////
 #include "mitkIRenderWindowPartListener.h"             ///////
 #include <itkImage.h>                                  ///////
 //////////////////////////////////////////////////////////////
 /**
   \brief PointSetInteractionMultispectrum
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \sa QmitkAbstractView
   \ingroup ${plugin_target}_internal
 */
 
-
-
 class QmitkPointListWidget;
 
-
-
 class PointSetInteractionMultispectrum : public QmitkAbstractView
 {
-  // this is needed for all Qt objects that should have a Qt meta-object
-  // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
     PointSetInteractionMultispectrum();
 
 
   protected slots:
 
     /// \brief Called when the user clicks the GUI button
     void DoImageProcessing();
 
   protected:
 
 
     void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart);
     void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart);
 
 
     void CreateQtPartControl(QWidget *parent) override;
 
     void SetFocus() override;
 
-    /// \brief called by QmitkFunctionality when DataManager's selection has changed
     void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
                                      const QList<mitk::DataNode::Pointer>& nodes ) override;
 
     Ui::PointSetInteractionMultispectrumControls m_Controls;
 
   private:
 
     void PlotReflectance(mitk::PointSet::Pointer m_PointSet, QList<mitk::DataNode::Pointer> dataManagerNodes);
 
     mitk::PointSet::Pointer m_PointSet;
     QmitkPointListWidget* m_PointListWidget;
     QwtPlot* m_Plot;
 
-
-
-
 };
 
 #endif // PointSetInteractionMultispectrum_h
diff --git a/Plugins/org.mitk.gui.qt.preprocessing.resampling/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.preprocessing.resampling/manifest_headers.cmake
index 36feb434f4..c189578b09 100644
--- a/Plugins/org.mitk.gui.qt.preprocessing.resampling/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.preprocessing.resampling/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Preprocessing Resampling")
 set(Plugin-Version "1.0")
 set(Plugin-Vendor "German Cancer Research Center (DKFZ)")
 set(Plugin-ContactAddress "http://www.mitk.org")
-set(Require-Plugin org.mitk.gui.qt.common.legacy)
+set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.cpp b/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.cpp
index 0befa8495d..bed002ff32 100644
--- a/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.cpp
+++ b/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.cpp
@@ -1,457 +1,456 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkPreprocessingResamplingView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 
 // Berry includes (selection service)
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK includes (GUI)
-#include "QmitkStdMultiWidget.h"
 #include "QmitkDataNodeSelectionProvider.h"
 #include "mitkDataNodeObject.h"
 
 // MITK includes (general)
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateDimension.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkVectorImageMapper2D.h"
 #include "mitkProperties.h"
 #include "mitkLevelWindowProperty.h"
 
 // Includes for image casting between ITK and MITK
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 
 // ITK includes (general)
 #include <itkVectorImage.h>
 #include <itkImageFileWriter.h>
 
 // Resampling
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkLinearInterpolateImageFunction.h>
 
 #include <itkRescaleIntensityImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
 
 // STD
 #include <cmath>
 
 
 // Convenient Definitions
 typedef itk::Image<double, 3>                                                           ImageType;
 typedef itk::Image<unsigned char, 3>                                                    SegmentationImageType;
 typedef itk::Image<double, 3>                                                           DoubleImageType;
 typedef itk::Image<itk::Vector<float,3>, 3>                                             VectorImageType;
 
 typedef itk::ResampleImageFilter< ImageType, ImageType >                                ResampleImageFilterType;
 typedef itk::ResampleImageFilter< ImageType, ImageType >                                ResampleImageFilterType2;
 typedef itk::CastImageFilter< ImageType, DoubleImageType >                               ImagePTypeToFloatPTypeCasterType;
 
 typedef itk::LinearInterpolateImageFunction< ImageType, double >                        LinearInterpolatorType;
 typedef itk::NearestNeighborInterpolateImageFunction< ImageType, double >               NearestInterpolatorType;
 typedef itk::BSplineInterpolateImageFunction<ImageType, double>                         BSplineInterpolatorType;
 
 
 QmitkPreprocessingResampling::QmitkPreprocessingResampling()
 : QmitkAbstractView(),
   m_Controls(nullptr),
   m_SelectedImageNode(nullptr),
   m_TimeStepperAdapter(nullptr)
 {
 }
 
 QmitkPreprocessingResampling::~QmitkPreprocessingResampling()
 {
 }
 
 void QmitkPreprocessingResampling::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == nullptr)
   {
     m_Controls = new Ui::QmitkPreprocessingResamplingViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
     mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
   }
 
   m_SelectedImageNode = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
   // Setup Controls
   this->m_Controls->cbParam4->clear();
   this->m_Controls->cbParam4->insertItem(LINEAR, "Linear");
   this->m_Controls->cbParam4->insertItem(NEAREST, "Nearest neighbor");
   this->m_Controls->cbParam4->insertItem(SPLINE, "B-Spline");
 
 }
 
 void QmitkPreprocessingResampling::CreateConnections()
 {
   if ( m_Controls )
   {
     connect((QObject*)(m_Controls->btnDoIt), SIGNAL(clicked()), (QObject*) this, SLOT(StartButtonClicked()));
     connect((QObject*)(m_Controls->buttonExecuteOnMultipleImages), SIGNAL(clicked()), (QObject*) this, SLOT(StartMultipleImagesButtonClicked()));
     connect( (QObject*)(m_Controls->cbParam4), SIGNAL( activated(int) ), this, SLOT( SelectInterpolator(int) ) );
   }
 }
 
 void QmitkPreprocessingResampling::InternalGetTimeNavigationController()
 {
   auto renwin_part = GetRenderWindowPart();
   if( renwin_part != nullptr )
   {
     auto tnc = renwin_part->GetTimeNavigationController();
     if( tnc != nullptr )
     {
       m_TimeStepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls->sliceNavigatorTime, tnc->GetTime(), "sliceNavigatorTimeFromBIP");
     }
   }
 }
 
 void QmitkPreprocessingResampling::SetFocus()
 {
 }
 
 //datamanager selection changed
 void QmitkPreprocessingResampling::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   ResetOneImageOpPanel();
   //any nodes there?
   if (!nodes.empty())
   {
     // reset GUI
     m_Controls->sliceNavigatorTime->setEnabled(false);
     m_Controls->leImage1->setText(tr("Select an Image in Data Manager"));
 
     m_SelectedNodes.clear();
 
     for (mitk::DataNode* _DataNode : nodes)
     {
       m_SelectedImageNode->RemoveAllNodes();
       *m_SelectedImageNode = _DataNode;
       mitk::Image::Pointer tempImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
 
       //no image
       if (tempImage.IsNull() || (tempImage->IsInitialized() == false))
       {
         if (m_SelectedNodes.size() < 1)
         {
           m_Controls->leImage1->setText(tr("Not an image."));
         }
         continue;
       }
 
       //2D image
       if (tempImage->GetDimension() < 3)
       {
         if (m_SelectedNodes.size() < 1)
         {
           m_Controls->leImage1->setText(tr("2D images are not supported."));
         }
         continue;
       }
 
       if (m_SelectedNodes.size() < 1)
       {
         m_Controls->leImage1->setText(QString(m_SelectedImageNode->GetNode()->GetName().c_str()));
         mitk::Vector3D aSpacing = tempImage->GetGeometry()->GetSpacing();
         std::string text("x-spacing (" + std::to_string(aSpacing[0]) + ")");
         m_Controls->tlParam1->setText(text.c_str());
         text = "y-spacing (" + std::to_string(aSpacing[1]) + ")";
         m_Controls->tlParam2->setText(text.c_str());
         text = "z-spacing (" + std::to_string(aSpacing[2]) + ")";
         m_Controls->tlParam3->setText(text.c_str());
 
         if (tempImage->GetDimension() > 3)
         {
           // try to retrieve the TNC (for 4-D Processing )
           this->InternalGetTimeNavigationController();
 
           m_Controls->sliceNavigatorTime->setEnabled(true);
           m_Controls->tlTime->setEnabled(true);
         }
       }
       m_SelectedNodes.push_back(_DataNode);
     }
     if (m_SelectedNodes.size() > 0)
     {
       *m_SelectedImageNode = m_SelectedNodes[0];
     }
     ResetParameterPanel();
   }
 }
 
 void QmitkPreprocessingResampling::ResetOneImageOpPanel()
 {
   m_Controls->tlTime->setEnabled(false);
   m_Controls->btnDoIt->setEnabled(false);
   m_Controls->buttonExecuteOnMultipleImages->setEnabled(false);
   m_Controls->cbHideOrig->setEnabled(false);
   m_Controls->leImage1->setText(tr("Select an Image in Data Manager"));
   m_Controls->tlParam1->setText("x-spacing");
   m_Controls->tlParam1->setText("y-spacing");
   m_Controls->tlParam1->setText("z-spacing");
 }
 
 void QmitkPreprocessingResampling::ResetParameterPanel()
 {
   m_Controls->btnDoIt->setEnabled(true);
   m_Controls->buttonExecuteOnMultipleImages->setEnabled(true);
   m_Controls->cbHideOrig->setEnabled(true);
 }
 
 void QmitkPreprocessingResampling::ResetTwoImageOpPanel()
 {
 }
 
 void QmitkPreprocessingResampling::StartMultipleImagesButtonClicked()
 {
   for (auto currentSelectedNode : m_SelectedNodes)
   {
     m_SelectedImageNode->RemoveAllNodes();
     *m_SelectedImageNode = currentSelectedNode;
     StartButtonClicked();
   }
 }
 
 void QmitkPreprocessingResampling::StartButtonClicked()
 {
   if(!m_SelectedImageNode->GetNode()) return;
 
   this->BusyCursorOn();
 
   mitk::Image::Pointer newImage;
 
   try
   {
     newImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
   }
   catch ( std::exception &e )
   {
   QString exceptionString = tr("An error occured during image loading:\n");
   exceptionString.append( e.what() );
     QMessageBox::warning( nullptr, "Preprocessing - Resampling: ", exceptionString , QMessageBox::Ok, QMessageBox::NoButton );
     this->BusyCursorOff();
     return;
   }
 
   // check if input image is valid, casting does not throw exception when casting from 'NULL-Object'
   if ( (! newImage) || (newImage->IsInitialized() == false) )
   {
     this->BusyCursorOff();
 
     QMessageBox::warning( nullptr, "Preprocessing - Resampling", tr("Input image is broken or not initialized. Returning."), QMessageBox::Ok, QMessageBox::NoButton );
     return;
   }
 
   // check if operation is done on 4D a image time step
   if(newImage->GetDimension() > 3)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(newImage);
     timeSelector->SetTimeNr( ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos() );
     timeSelector->Update();
     newImage = timeSelector->GetOutput();
   }
 
   // check if image or vector image
   ImageType::Pointer itkImage = ImageType::New();
   VectorImageType::Pointer itkVecImage = VectorImageType::New();
 
   int isVectorImage = newImage->GetPixelType().GetNumberOfComponents();
 
   if(isVectorImage > 1)
   {
     CastToItkImage( newImage, itkVecImage );
   }
   else
   {
     CastToItkImage( newImage, itkImage );
   }
 
   std::stringstream nameAddition("");
 
   double dparam1 = m_Controls->dsbParam1->value();
   double dparam2 = m_Controls->dsbParam2->value();
   double dparam3 = m_Controls->dsbParam3->value();
 
   try{
 
       std::string selectedInterpolator;
       ResampleImageFilterType::Pointer resampler = ResampleImageFilterType::New();
       switch (m_SelectedInterpolation)
       {
       case LINEAR:
         {
           LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Linear";
           break;
         }
       case NEAREST:
         {
           NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Nearest";
           break;
       }
       case SPLINE:
       {
         BSplineInterpolatorType::Pointer interpolator = BSplineInterpolatorType::New();
         interpolator->SetSplineOrder(3);
         resampler->SetInterpolator(interpolator);
         selectedInterpolator = "B-Spline";
         break;
       }
       default:
         {
           LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Linear";
           break;
         }
       }
       resampler->SetInput( itkImage );
       resampler->SetOutputOrigin( itkImage->GetOrigin() );
 
       ImageType::SizeType input_size = itkImage->GetLargestPossibleRegion().GetSize();
       ImageType::SpacingType input_spacing = itkImage->GetSpacing();
 
       ImageType::SizeType output_size;
       ImageType::SpacingType output_spacing;
 
       if (dparam1 > 0)
       {
         output_size[0] = std::ceil(input_size[0] * (input_spacing[0] / dparam1));
         output_spacing[0] = dparam1;
       }
       else
       {
         output_size[0] = std::ceil(input_size[0] * (-1.0 / dparam1));
         output_spacing[0] = -1.0*input_spacing[0] * dparam1;
       }
       if (dparam2 > 0)
       {
         output_size[1] = std::ceil(input_size[1] * (input_spacing[1] / dparam2));
         output_spacing[1] = dparam2;
       }
       else
       {
         output_size[1] = std::ceil(input_size[1] * (-1.0 / dparam2));
         output_spacing[1] = -1.0*input_spacing[1] * dparam2;
       }
       if (dparam3 > 0)
       {
         output_size[2] = std::ceil(input_size[2] * (input_spacing[2] / dparam3));
         output_spacing[2] = dparam3;
       }
       else
       {
         output_size[2] = std::ceil(input_size[2] * (-1.0 / dparam3));
         output_spacing[2] = -1.0*input_spacing[2] * dparam3;
       }
 
       resampler->SetSize( output_size );
       resampler->SetOutputSpacing( output_spacing );
       resampler->SetOutputDirection( itkImage->GetDirection() );
 
       resampler->UpdateLargestPossibleRegion();
 
       ImageType::Pointer resampledImage = resampler->GetOutput();
 
       newImage = mitk::ImportItkImage( resampledImage )->Clone();
       nameAddition << "_Resampled_" << selectedInterpolator;
       std::cout << "Resampling successful." << std::endl;
   }
   catch (...)
   {
     this->BusyCursorOff();
     QMessageBox::warning(nullptr, "Warning", "Problem when applying filter operation. Check your input...");
     return;
   }
 
   newImage->DisconnectPipeline();
 
   // adjust level/window to new image
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( newImage );
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
 
   // compose new image name
   std::string name = m_SelectedImageNode->GetNode()->GetName();
   if (name.find(".nrrd") == name.size() -5 )
   {
     name = name.substr(0,name.size() -5);
   }
   name.append( nameAddition.str() );
 
   // create final result MITK data storage node
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "levelwindow", levWinProp );
   result->SetProperty( "name", mitk::StringProperty::New( name.c_str() ) );
   result->SetData( newImage );
 
   // for vector images, a different mapper is needed
   if(isVectorImage > 1)
   {
     mitk::VectorImageMapper2D::Pointer mapper =
       mitk::VectorImageMapper2D::New();
     result->SetMapper(1,mapper);
   }
 
   // add new image to data storage and set as active to ease further processing
   GetDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
   if ( m_Controls->cbHideOrig->isChecked() == true )
     m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
 
   // show the results
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->BusyCursorOff();
 }
 
 void QmitkPreprocessingResampling::SelectInterpolator(int interpolator)
 {
   switch (interpolator)
   {
   case 0:
     {
       m_SelectedInterpolation = LINEAR;
       break;
     }
   case 1:
     {
       m_SelectedInterpolation = NEAREST;
       break;
     }
   case 2:
   {
     m_SelectedInterpolation = SPLINE;
   }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.h b/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.h
index 8d9d85ddeb..b24d8f7e0d 100644
--- a/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.h
+++ b/Plugins/org.mitk.gui.qt.preprocessing.resampling/src/internal/QmitkPreprocessingResamplingView.h
@@ -1,131 +1,122 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #if !defined(QmitkPreprocessingResamplingView_H__INCLUDED)
 #define QmitkPreprocessingResamplingView_H__INCLUDED
 
 #include <QmitkAbstractView.h>
 #include <org_mitk_gui_qt_preprocessing_resampling_Export.h>
 #include "ui_QmitkPreprocessingResamplingViewControls.h"
 
 #include "QmitkStepperAdapter.h"
 
 #include <mitkDataStorageSelection.h>
 
 /*!
 \brief This module allows to use some basic image processing filters for preprocessing, image enhancement and testing purposes
 
 Several basic ITK image processing filters, like denoising, morphological and edge detection
 are encapsulated in this module and can be selected via a list and an intuitive parameter input.
 The selected filter will be applied on the image, and a new image showing the output is displayed
 as result.
 Also, some image arithmetic operations are available.
 
 Images can be 3D or 4D.
 In the 4D case, the filters work on the 3D image selected via the
 time slider. The result is also a 3D image.
-
-\sa QmitkFunctionality, QObject
-
-\class QmitkBasicImageProcessing
-\author Tobias Schwarz
-\version 1.0 (3M3)
-\date 2009-05-10
-\ingroup Bundles
 */
 
 class PREPROCESSING_RESAMPLING_EXPORT QmitkPreprocessingResampling : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   /*!
   \brief default constructor
   */
   QmitkPreprocessingResampling();
 
   /*!
   \brief default destructor
   */
   ~QmitkPreprocessingResampling() override;
 
   /*!
   \brief method for creating the widget containing the application controls, like sliders, buttons etc.
   */
   void CreateQtPartControl(QWidget *parent) override;
 
   void SetFocus() override;
 
   /*!
   \brief method for creating the connections of main and control widget
   */
   virtual void CreateConnections();
 
   /*!
   \brief Invoked when the DataManager selection changed
   */
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes) override;
 
 
   protected slots:
 
     /*
     * The "Execute" button in the "one image ops" box was triggered
     */
     void StartButtonClicked();
 
     void StartMultipleImagesButtonClicked();
 
     void SelectInterpolator(int interpolator);
 
 private:
 
   /*
   * After a one image operation, reset the "one image ops" panel
   */
   void ResetOneImageOpPanel();
 
   /*
   * Helper method to reset the parameter set panel
   */
   void ResetParameterPanel();
 
   /*
   * After a two image operation, reset the "two image ops" panel
   */
   void ResetTwoImageOpPanel();
 
   /** retrieve the tnc from renderwindow part */
   void InternalGetTimeNavigationController();
 
   /*!
   * controls containing sliders for scrolling through the slices
   */
   Ui::QmitkPreprocessingResamplingViewControls *m_Controls;
 
-  //mitk::DataNode*       m_SelectedImageNode;
   mitk::DataStorageSelection::Pointer m_SelectedImageNode;
   QmitkStepperAdapter*      m_TimeStepperAdapter;
 
   std::vector<mitk::DataNode::Pointer> m_SelectedNodes;
 
   enum InterpolationType{
     LINEAR,
     NEAREST,
     SPLINE
   } m_SelectedInterpolation;
 };
 
-#endif // !defined(QmitkBasicImageProcessing_H__INCLUDED)
+#endif
 
 
diff --git a/Plugins/org.mitk.gui.qt.segmentation/CMakeLists.txt b/Plugins/org.mitk.gui.qt.segmentation/CMakeLists.txt
index dd2ab4fc65..92eac09671 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.segmentation/CMakeLists.txt
@@ -1,10 +1,10 @@
 project(org_mitk_gui_qt_segmentation)
 
 include_directories(${CTK_INCLUDE_DIRS})
 
 mitk_create_plugin(
   EXPORT_DIRECTIVE MITK_QT_SEGMENTATION
   EXPORTED_INCLUDE_SUFFIXES src
   MODULE_DEPENDS MitkAppUtil MitkQtWidgetsExt MitkSegmentationUI
-  PACKAGE_DEPENDS Qt5|OpenGL
+  PACKAGE_DEPENDS Qt5|OpenGL nlohmann_json
 )
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox
index 17cd1deb32..8ce127d60b 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox
+++ b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox
@@ -1,392 +1,405 @@
 /**
 \page org_mitk_views_segmentation The Segmentation View
 
 \imageMacro{segmentation-dox.svg,"Icon of the segmentation view",2.00}
 
 <i>Some of the features described below are closed source additions to the open source toolkit MITK and are not  available in every application.</i>
 
 \tableofcontents
 
 \section org_mitk_views_segmentationoverview Overview
 
 Segmentation is the act of partitioning an image into subsets by either manual or automated delineation to create i.e. a distinction between foreground and background.
 A multilabel segmentation can contain more than one label and more than one layer.
 This allows you to create different labels for different regions of interest encapsulated in one single image.
 The difference between labels and layers is that labels on one layer cannot overlap but labels on different layers can.
 
 The MITK <b>segmentation plugin</b> allows you to create multilabel segmentations of anatomical and pathological structures in medical images.
 The plugin consists of two views:
 <ul>
   <li> <b>Segmentation View</b>: Manual and (semi-)automatic segmentation
   <li> \subpage org_mitk_views_segmentationutilities : Segmentation post-processing
 </ul>
 In this documentation, the features and usage of the segmentation view will be described.
 For an introduction to the segmentation utilities please be referred to the respective documentation pages.
 
 \imageMacro{QmitkSegmentationPlugin_Overview.png,"Segmentation plugin overview", 16.00}
 
 \section org_mitk_views_segmentationpreferences Preferences
 The segmentation plugin offers a number of preferences which can be set via the MITK Workbench application preferences:
 
 \imageMacro{QmitkSegmentationPreferences.png,"Segmentation preferences", 10.00}
 
 <ul>
   <li> <b>Slim view:</b> Allows to show or hide the tool button description of the segmentation view
   <li> <b>2D display:</b> Specify whether the segmentation is drawn as outline or as a transparent overlay
   <li> <b>Show only selected nodes:</b> Enable if only the selected segmentation and the reference image should be visible
   <li> <b>Smoothed surface creation:</b> Set certain smoothing parameters for surface creation
   <li> <b>Default label set preset:</b> Start a new segmentation with this preset instead of a default label
+  <li> <b>Label creation:</b> Assign default names and colors to new labels or ask users for them
+  <li> <b>Label suggestions:</b> Specify custom suggestions for label names and colors
 </ul>
 
 \section org_mitk_views_segmentationtechnicalissues Technical issues
 
 The segmentation plugin makes a number of assumptions:
 <ul>
   <li> Images must be 2D, 3D, or 3D+t.
   <li> Images must be single-values, i.e. CT, MRI or "normal" ultrasound. Images from color doppler or photographic (RGB) images are only partially supported (please be aware that some tools might not be compatible with this image type).
   <li> Segmentations are handled as multilabel images of the same extent as the original image.
 </ul>
 
 \section org_mitk_views_segmentationdataselection Data selection & creating new segmentations
 
 To select a reference image for the segmentation, click on the <i>Selected image</i> selection widget and choose a suitable image from the selection available in the data manager.
 Once an image is selected, a new segmentation can be created on this reference image by clicking the button to the right of the <i>Selected segmentation</i> selection widget.
 A new multilabel segmentation with an initial label is automatically generated.
 The new segmentation will be added to the data manager as sub-node of the reference image.
 This item is then automatically selected in the data selection, which allows to start editing the new segmentation right away.
 
 \imageMacro{"QmitkSegmentation_DataSelection.png","Data selection",12}
 
 Alternatively to creating a new segmentation, an existing one can be edited as well.
 If a reference image is selected for which a segmentation already exists in the data manager, the auto selection mode will automatically
 select a fitting segmentation.
 Clicking on the segmentation selection widget a drop down list will open, containing all suitable segmentations for the selected reference dataset available in the data manager.
 
 \section org_mitk_views_segmentationlayers Segmentation layers
 
 For each multilabel segmentation different layers can be added or deleted. The layers can be used independently and layers can be switched using the left and right arrows.
 A layer is a set of labels that occupy a non-overlapping anatomical space. The best way to describe them is by a real use case:
 Imagine you are working on a radiotherapy planning application. In the first layer of your segmentation session, you would like to trace the contours of the liver and neighboring organs.
 You can accommodate all these segmentations in separate labels because they all occupy different anatomical regions and do not overlap.
 Now say you would like to segment the arteries and veins inside the liver. If you don't trace them in a different layer, you will overwrite the previous ones.
 You may also need a third layer for segmenting the different irrigation territories in the liver and a fourth layer to contain the lesion you would like to treat.
 
 \imageMacro{"QmitkSegmentation_LayerSelection.png","Layer selection",12}
 
 \section org_mitk_views_segmentationlabels Segmentation labels
 
 For each layer, one or more labels can be added. Pressing the double arrow on the right, all created labels are shown in the 'Label Table'.
 The following label properties are available:
 
 <ul>
   <li><b>Name:</b></li> the name of the label. Can be a predefined one or any other.
   <li><b>Locked:</b></li> whether the label is locked or editable. A locked label cannot be overwritten by another.
   <li><b>Color:</b></li> the color of the label.
   <li><b>Visible:</b></li> whether the label is currently visible or hidden.
 </ul>
 
 \imageMacro{"QmitkSegmentation_LabelTable.png","The 'Label Table' shows all labels in the current segmentation session",12}
 
 The 'New Label' button can be used to add a new label. This will automatically add a new label with a distinct name and color to the list of available labels.\n
 In the current implementation of the plugin, the maximum number of labels is restricted to 255. If you need more, you will have to create a new segmentation session.
 
+\subsection org_mitk_views_segmentationlabelsuggestions Label name and color suggestions
+
+When renaming labels or creating new labels with enforced manual naming in the Segmentation preferences, entering names is supported by auto-completion for common label names.
+The list of predefined label names and colors for the auto-completion feature can be either extented or replaced by a custom list of label name and color suggestions.
+This custom list must be specified as a JSON file, just containing an array of objects, each with a mandatory "name" string and an optional "color" string.
+The JSON file can be set in the Segmentation preferences as well as a few options on how to apply these suggestions.
+
 \subsection org_mitk_views_segmentationlabelpresets Saving and loading label set presets
 
 Label set presets are useful to share a certain style or scheme between different segmentation sessions or to provide templates for new segmentation sessions.
 
 The properties of all labels in all layers like their names, colors, and visibilities are saved as a label set preset by clicking on the 'Save label set preset' button.
 Label set presets are applied to any segmentation session by clicking on the 'Load label set preset' button.
 If a label for a certain value already exists, its properties are overridden by the preset.
 If a label for a certain value does not yet exist, an empty label with the label properties of the preset is created.
 The actual segmentations of labels are unaffected as label set presets only store label properties.
 
 \subsubsection org_mitk_views_segmentationdefaultlabelpresets Applying label set presets by default
 
 If you work on a repetetive segmentation task, manually loading the same label set preset for each and every new segmentation can be tedious.
 To streamline your workflow, you can set a default label set preset in the Segmentation preferences (Ctrl+P). When set, this label set preset will be applied to all new segmentations instead of creating the default red "New label 1" label.
 
 \subsection org_mitk_views_segmentationlabelsearch Searching for a label
 
 It may happen that many labels (e.g. > 200) are present in a segmentation session and therefore manual searching can be time-consuming.
 The 'Label Search' edit box allows for quickly finding a label by providing assistance for label name completion.
 If the label is found, it will become the active one after pressing 'enter'.
 
 To start editing a label needs to be activated by clicking on the corresponding row in the 'Label Table'.
 Only one label can be active at the time. Then the segmentation tools in the toolbox can be used for mask generation.
 
 \subsection org_mitk_views_multilabelsegmentationoperationsonlabels Operations on labels
 Depending on the selection in the 'Label Table', several actions are offered:
 
 \subsubsection org_mitk_views_segmentationoperationssingleselection Operations with single label selection
 
 Right-clicking on any label opens a pop-up menu that offers the following actions to be performed on the selected label:
 
 <ul>
   <li><b>Rename...</b></li> : change the name and / or color of the selected label.
   <li><b>Remove...</b></li> : delete the selected label.
   <li><b>Erase...</b></li> : only clear the contents of the selected label.
   <li><b>Merge...</b></li> : merge two labels by selecting a second label.
   <li><b>Random color </b></li> : assign a random color to the label.
   <li><b>View only </b></li> : make all labels except the current selected label invisible.
   <li><b>View/Hide all </b></li> : make all labels visible / invisible
   <li><b>Lock/Unlock all </b></li> : lock or unlock all labels.
   <li><b>Create surface </b></li> : generate a surface out of the selected label.
     <li><b>Create mask </b></li> : generate a mask out of the selected label. A mask is a binary image with "1" inside and "0" outside.
 	<li><b>Create cropped mask </b></li> : generate a binary mask out of the selected label. Crop changes the extent of the resulting image to the extent of the label.
 </ul>
 
 \imageMacro{"QmitkSegmentation_OperationsSingleSelection.png","Context menu for single label selection",12}
 
 \subsubsection org_mitk_views_segmentationoperationsmultiselection Operations with multiple label selection
 
 Shift-clickink on multiple labels allows to select more than one label. If more than one label is selected, different options will appear in the menu:
 
 <ul>
   <li><b>Merge selection on current label</b></li> : transfer the contents of the selected labels in the 'Label Table' into the current one.
   <li><b>Remove selected labels</b></li> : delete the selected labels.
   <li><b>Erase selected labels</b></li> : only clear the contents of the selected labels.
 </ul>
 
 \imageMacro{"QmitkSegmentation_OperationsMultiSelection.png","Context menu for multiple label selection",12}
 
 \section org_mitk_views_segmentationtooloverview Segmentation tool overview
 
 MITK offers a comprehensive set of slice-based 2D and (semi-)automated 3D segmentation tools.
 The manual 2D tools require some user interaction and can only be applied to a single image slice whereas the 3D tools operate on the whole image.
 The 3D tools usually only require a small amount of user interaction, i.e. placing seed points or setting / adjusting parameters.
 You can switch between the different toolsets by selecting the 2D or 3D tab in the segmentation view.
 
 \imageMacro{QmitkSegmentation_ToolOverview.png,"An overview of the existing 2D and 3D tools in MITK.",5.50}
 
 \section org_mitk_views_segmentation2dsegmentation 2D segmentation tools
 
 With 2D manual contouring you define which voxels are part of the segmentation and which are not. This allows you to create segmentations of any structures of interest in an image.
 You can also use manual contouring to correct segmentations that result from sub-optimal automatic methods.
 The drawback of manual contouring is that you might need to define contours on many 2D slices. However, this is mitigated by the interpolation feature, which will make suggestions for a segmentation.
 
 To start using one of the editing tools, click its button from the displayed toolbox.
 The selected editing tool will be active and its corresponding button will stay pressed until you click the button again.
 Selecting a different tool also deactivates the previous one.\n
 If you have to delineate a lot of images, shortcuts to switch between tools becomes convenient.
 For that, just hit the first letter of each tool to activate it (A for Add, S for Subtract, etc.).
 
 All of the editing tools work by the same principle: using the mouse (left button) to click anywhere in a 2D window (any of the orientations axial, sagittal, or coronal),
 moving the mouse while holding the mouse button and releasing the button to finish the editing action.
 Multi-step undo and redo is fully supported by all editing tools by using the application-wide undo / redo buttons in the toolbar.
 
 <i>Remark</i>: Clicking and moving the mouse in any of the 2D render windows will move the crosshair that defines what part of the image is displayed.
 This behavior is disabled as long as any of the manual segmentation tools are active - otherwise you might have a hard time concentrating on the contour you are drawing.
 
 \subsection org_mitk_views_segmentationaddsubtracttools Add and subtract tools
 \imageMacro{QmitkSegmentation_IMGIconAddSubtract.png,"Add and subtract tools",7.70}
 
 Use the left mouse button to draw a closed contour. When releasing the mouse button, the contour will be added (Add tool) to or removed (Subtract tool) from the current segmentation.
 Adding and subtracting voxels can be iteratively repeated for the same segmentation. Holding CTRL / CMD while drawing will invert the current tool's behavior (i.e. instead of adding voxels, they will be subtracted).
 
 \subsection org_mitk_views_segmentationpaintwipetools Paint and wipe tools
 \imageMacro{QmitkSegmentation_IMGIconPaintWipe.png,"Paint and wipe tools",7.68}
 
 Use the <i>Size</i> slider to change the radius of the round paintbrush tool. Move the mouse in any 2D window and press the left button to draw or erase pixels.
 Holding CTRL / CMD while drawing will invert the current tool's behavior (i.e. instead of painting voxels, they will be wiped).
 
 \subsection org_mitk_views_segmentationregiongrowingtool Region growing tool
 \imageMacro{QmitkSegmentation_IMGIconRegionGrowing.png,"Region growing tool",3.81}
 
 Click at one point in a 2D slice widget to add an image region to the segmentation with the region growing tool.
 Region Growing selects all pixels around the mouse cursor that have a similar gray value as the pixel below the mouse cursor.
 This allows to quickly create segmentations of structures that have a good contrast to surrounding tissue.
 The tool operates based on the current level window, so changing the level window to optimize the contrast for the ROI is encouraged.
 Moving the mouse up / down is different from left / right:
 Moving up the cursor while holding the left mouse button widens the range for the included grey values; moving it down narrows it.
 Moving the mouse left and right will shift the range.
 The tool will select more or less pixels, corresponding to the changing gray value range.
 
 \if THISISNOTIMPLEMENTEDATTHEMOMENT
 A common issue with region growing is the so called "leakage" which happens when the structure of interest is connected to other pixels, of similar gray values, through a narrow "bridge" at the border of the structure.
 The Region Growing tool comes with a "leakage detection/removal" feature. If leakage happens, you can left-click into the leakage region and the tool will try to automatically remove this region (see illustration below).
 
 \imageMacro{QmitkSegmentation_Leakage.png,"Leakage correction feature of the region growing tool",11.28}
 \endif
 
 \subsection org_mitk_views_segmentationfilltool Fill tool
 \imageMacro{QmitkSegmentation_IMGIconFill.png,"Fill tool",3.81}
 
 Left-click inside a segmentation with holes to completely fill all holes. Left-click inside a hole to fill only this specific hole.
 
 \subsection org_mitk_views_segmentationerasetool Erase tool
 
 \imageMacro{QmitkSegmentation_IMGIconErase.png,"Erase tool",3.79}
 
 This tool removes a connected part of pixels that form a segmentation.
 You may use it to remove single segmentations (left-click on specific segmentation) or to clear a whole slice at once (left-click outside a segmentation).
 
 \subsection org_mitk_views_segmentationlivewiretool Live wire tool
 
 \imageMacro{QmitkSegmentation_IMGIconLiveWire.png,"Live wire tool",3.01}
 
 The Live Wire Tool acts as a magnetic lasso with a contour snapping to edges of objects.
 
 \imageMacro{QmitkSegmentation_IMGLiveWireUsage.PNG,"Steps for using the Live Wire Tool",16.00}
 
 <ul>
   <li>(1) To start the tool you have to double-click near the edge of the object you want to segment. The initial anchor point will snap to the edge within a 3x3 region.
   <li>(2) Move the mouse. You don't have trace the edge of the object. The contour will automatically snap to it.
   <li>(3) To fix a segment you can set anchor points by single left mouse button click.
   <li>(4) Go on with moving the mouse and setting anchor points.
   <li>(5) To close the contour double-click on the initial anchor point.
   <li>(6) After closing, the contour can be edited by moving, inserting and deleting anchor points.
 </ul>
 
 The contour will be transferred to its binary image representation by deactivating the tool.
 
 \subsection org_mitk_views_segmentationinterpolation 2D and 3D Interpolation
 
 Creating segmentations using 2D manual contouring for large image volumes may be very time-consuming, because structures of interest may cover a large range of slices.
 Note: Interpolation is currently disabled for segmentations containing more than one label.
 The segmentation view offers two helpful features to mitigate this drawback:
 
 <ul>
   <li> 2D Interpolation
   <li> 3D Interpolation
 </ul>
 
 The <b>2D Interpolation</b> creates suggestions for a segmentation whenever you have a slice that
 
 <ul>
   <li> has got neighboring slices with segmentations (these do not need to be direct neighbors but could also be a couple of slices away) AND
   <li> is completely clear of a manual segmentation, i.e. there will be no suggestion if there is even only a single pixel of segmentation in the current slice.
 </ul>
 
 \imageMacro{QmitkSegmentation_2DInterpolation.png,"2D interpolation usage",3.01}
 
 Interpolated suggestions are displayed as outlines, until you confirm them as part of the segmentation.
 To confirm single slices, click the <i>Confirm for single slice</i> button below the toolbox. You may also review the interpolations visually and then accept all of them at once by selecting <i>Confirm for all slices</i>.
 
 The <b>3D interpolation</b> creates suggestions for 3D segmentations. That means if you start contouring, from the second contour onwards, the surface of the segmented area will be interpolated based on the given contour information.
 The interpolation works with all available manual tools. Please note that this is currently a pure mathematical interpolation, i.e. image intensity information is not taken into account.
 With each further contour the interpolation result will be improved, but the more contours you provide the longer the recalculation will take.
 To achieve an optimal interpolation result and in this way a most accurate segmentation you should try to describe the surface with sparse contours by segmenting in arbitrary
 oriented planes. The 3D interpolation is not meant to be used for parallel slice-wise segmentation, but rather segmentations in i.e. the axial, coronal and sagittal plane.
 
 \imageMacro{QmitkSegmentation_3DInterpolationWrongRight.png,"3D interpolation usage",16.00}
 
 You can accept the interpolation result by clicking the <i>Confirm</i>-button below the tool buttons.
 In this case the 3D interpolation will be deactivated automatically so that the result can be post-processed without any interpolation running in the background.
 
 Additional to the surface, black contours are shown in the 3D render window, which mark all the drawn contours used for the interpolation.
 You can navigate between the drawn contours by clicking on the corresponding <i>position</i> nodes in the data manager which are stored as sub-nodes of the selected segmentation.
 If you do not want to see these nodes just uncheck the <i>Show Position Nodes</i> checkbox and these nodes will be hidden.
 
 If you want to delete a drawn contour we recommend to use the Erase-Tool since undo / redo is not yet working for 3D interpolation.
 The current state of the 3D interpolation can be saved across application restart. For that, just click on save project during the interpolation is active.
 After restarting the application and load your project you can click on "Reinit Interpolation" within the 3D interpolation GUI area.
 
 \section org_mitk_views_segmentation3dsegmentation 3D segmentation tools
 
 The 3D tools operate on the whole image and require usually a small amount of interaction like placing seed-points or specifying certain parameters. All 3D tools provide
 an immediate segmentation feedback, which is displayed as a transparent green overlay. For accepting a preview you have to press the <i>Confirm</i> button of the selected tool.
 The following 3D tools are available:
 
 \subsection org_mitk_views_segmentation3dthresholdtool 3D Threshold tool
 
 The thresholding tool simply applies a 3D threshold to the patient image. All pixels with values equal or above the selected threshold are labeled as part of the segmentation.
 You can change the threshold by either moving the slider of setting a certain value in the spinbox.
 
 \imageMacro{QmitkSegmentation_3DThresholdTool.png,"3D Threshold tool",10.00}
 
 \subsection org_mitk_views_segmentation3dulthresholdTool 3D upper / lower threshold tool
 
 The Upper/Lower Thresholding tool works similar to the simple 3D threshold tool but allows you to define an upper and lower threshold. All pixels with
 values within this threshold interval will be labeled as part of the segmentation.
 
 \imageMacro{QmitkSegmentation_3DULThresholdTool.png,"3D upper / lower threshold tool",10.00}
 
 \subsection org_mitk_views_segmentation3dotsutool 3D Otsu tool
 
 The 3D Otsu tool provides a more sophisticated thresholding algorithm. It allows you to define a number of regions. Based on the image histogram the pixels will
 then be divided into different regions. The more regions you define the longer the calculation will take. You can select afterwards which of these regions you want to confirm as segmentation.
 
 \imageMacro{QmitkSegmentation_3DOtsuTool.png,"3D Otsu tool",10.00}
 
 \subsection org_mitk_views_segmentation3drgtool 3D Region growing tool
 
 The 3D Region Growing tool works similar to the 2D pendant. At the beginning you have to place a seedpoint and define a threshold interval. If you press
 <i>Run Segmentation</i> a preview is calculated. By moving the <i>Adapt region growing</i> slider you can interactively adapt the segmentation result.
 
 \imageMacro{QmitkSegmentation_3DRGTool.png,"3D Region growing tool",10.00}
 
 \subsection org_mitk_views_segmentationpickingtool Picking Tool
 
-The Picking tool allows you to select islands within your segmentation. This is especially useful if e.g. a thresholding provided you with several areas within
+The Picking tool offers two modes that allow you to manipulate "islands" within your segmentation. This is especially useful if e.g. a thresholding provided you with several areas within
 your image but you are just interested in one special region.
+- Picking mode: Allows you to select certain "islands". When the pick is confirmed, the complete content of the active label will be removed except the pick. This mode is beneficial if you have a lot segmentation noise and want to pick the relevant parts and dismiss the rest. Hint: You can also pick from other labels, but this will only work if these labels are unlocked.
+- Relabel mode: Allows you to select certain "islands". When the pick is confirmed, it will be relabeled and added to the active label content. Hint: This mode ignores the locks of other labels, hence you do not need to unlock them explicitly.
 
 \imageMacro{QmitkSegmentation_PickingTool.png,"Picking tool",10.00}
 
 \subsection org_mitk_views_segmentationnnUNetTool nnU-Net Tool (Ubuntu only)
 
 \imageMacro{QmitkSegmentation_nnUnetTool.png,"nnUNet tool",10.00}
 
 This tool provides a GUI to the deep learning-based segmentation algorithm called the nnUNet. With this tool, you can get a segmentation mask predicted for the loaded image in MITK. Be ready with the pre-trained weights (a.k.a <b>RESULTS_FOLDER</b>)
 for your organ or task concerned, before using the tool. For a detailed explanation of the parameters and pre-trained weights folder structure etc., please refer to https://github.com/MIC-DKFZ/nnUNet. <br>
 Remark: The tool assumes that you have a Python3 environment with nnUNet (pip) installed. Your machine should be also equipped with a CUDA enabled GPU.
 
 \subsubsection org_mitk_views_segmentationnnUNetToolWorkflow Workflow:
-    -# Select the "Python Path" drop-down to see if MITK has automatically detected other Python environments. 
+    -# Select the "Python Path" drop-down to see if MITK has automatically detected other Python environments.
     Click on a fitting environment for the nnUNet inference or click "Select" in the dropdown to choose an unlisted python environment. Note that, while selecting an arbitrary environment folder, only select the base folder, e.g. "myenv".
     No need to select all the way until "../myenv/bin/python", for example.
-    -# Click on the "nnUNet Results Folder" directory icon to navigate to the results folder on your hard disk. This is equivalent to setting the <b>RESULTS_FOLDER</b> environment variable. If your results folder is as 
-    per the nnUNet required folder structure, the configuration, trainers, tasks and folds are automatically parsed and correspondingly loaded in the drop-down boxes as shown below. Note that MITK automatically checks for the 
+    -# Click on the "nnUNet Results Folder" directory icon to navigate to the results folder on your hard disk. This is equivalent to setting the <b>RESULTS_FOLDER</b> environment variable. If your results folder is as
+    per the nnUNet required folder structure, the configuration, trainers, tasks and folds are automatically parsed and correspondingly loaded in the drop-down boxes as shown below. Note that MITK automatically checks for the
     <b>RESULTS_FOLDER</b> environment variable value and, if found, auto parses that directory when the tool is started.
     \imageMacro{QmitkSegmentation_nnUNet_Settings.png,"nnUNet Segmentation Settings",10}
     -# Choose your required Task-Configuration-Trainer-Planner-Fold parameters, sequentially. By default, all entries are selected inside the "Fold" dropdown (shown: "All").
     Note that, even if you uncheck all entries from the "Fold" dropdown (shown: "None"), then too,  all folds would be considered for inferencing.
     -# For ensemble predictions, you will get the option to select parameters irrespective on postprocessing files available in the ensembles folder of <b>RESULTS_FOLDER</b>.
     Note that, if a postprocessing json file exists for the selected combination then it will used for ensembling, by default. To choose not to, uncheck the "Use PostProcessing JSON" in the "Advanced" section.
     \imageMacro{QmitkSegmentation_nnUNet_ensemble.png,"nnUNet Segmentation Settings",10}
     -# If your task is trained with multi-modal inputs, then "Multi-Modal" checkbox is checked and the no.of modalities are preloaded in the "No. of Extra Modalities" spinbox.
-    Instantly, as much node selectors with corresponding modality names should appear below to select the Data Manager along including a selector with preselected with the reference node. 
+    Instantly, as much node selectors with corresponding modality names should appear below to select the Data Manager along including a selector with preselected with the reference node.
     Now, select the image nodes in the node selectors accordingly for accurate inferencing.
     \imageMacro{QmitkSegmentation_nnUNet_multimodal.png,"nnUNet Multi Modal Settings",10.00}
     -# Click on "Preview".
     -# In the "Advanced" section, you can also activate other options like "Mixed Precision" and "Enable Mirroring" (for test time data augmentation) pertaining to nnUNet.
     \imageMacro{QmitkSegmentation_nnUNet_Advanced.png,"nnUNet Advanced Settings",10.00}
     -# Use "Advanced" > "GPU Id" combobox to change the preferred GPU for inferencing. This is internally equivalent to setting the <b>CUDA_VISIBLE_DEVICES</b> environment variable.
     -# Every inferred segmentation is cached to prevent a redundant computation. In case, a user doesn't wish to cache a Preview, uncheck the "Enable Caching" in the "Advanced" section. This will ensure that the
     current parameters will neither be checked against the existing cache nor a segmentation be loaded from it when Preview is clicked.
     -# You may always clear all the cached segmentations by clicking "Clear Cache" button.
 
 \subsubsection org_mitk_views_segmentationnnUNetToolMisc Miscellaneous:
     -# In case you want to reload/reparse the folders in the "nnUNet Results Folder", eg. after adding new tasks into it, you may do so without reselecting the folder again by clicking the "Refresh Results Folder" button.
     -# The "Advanced" > "GPU Id" combobox lists the Nvidia GPUs available by parsing the <tt>nvidia-smi</tt> utility output. In case your machine has Nvidia CUDA enabled GPUs but the <tt>nvidia-smi</tt> fails for some reason, the "GPU Id" combobox will show no entries.
     In such a situation, it's still possible to execute inferencing by manually entering the preferred GPU Id, eg. 0 in the combobox.
+    -# The "Advanced" > "Available Models" lists the available pre-trained tasks for download. Make sure you have internet connection. Then, choose a Task from the dropdown and click the Download button. The pre-trained models for the selected Task
+    will be downloaded and placed to the <b>RESULTS_FOLDER</b> directory automatically.
     -# In the <b>RESULTS_FOLDER</b> directory, inside the trainer-planner folder of every task, MITK keeps a "mitk_export.json" file for fast loading for multi-modal information. It is recommended not to delete this file(s) for a fast responsive UI.
     Tip: If multi-modal information shown on MITK is not correct for a given task, you may modify this JSON file and try again.
 
 \section org_mitk_views_segmentationpostprocessing Additional things you can do with segmentations
 
 Segmentations are never an end in themselves. Consequently, the segmentation view adds a couple of "post-processing" actions, accessible through the context-menu of the data manager.
 
 \imageMacro{QmitkSegmentation_IMGDataManagerContextMenu.png,"Context menu items for segmentations",10.58}
 
 <ul>
 <li> <b>Create polygon %model</b> applies the marching cubes algorithm to the segmentation. This polygon %model can be used for visualization in 3D or other applications such as stereolithography (3D printing).
 <li> <b>Create smoothed polygon %model</b> uses smoothing in addition to the marching cubes algorithm, which creates models that do not follow the exact outlines of the segmentation, but look smoother.
 <li> <b>Autocrop</b> can save memory. Manual segmentations have the same extent as the patient image, even if the segmentation comprises only a small sub-volume. This invisible and meaningless margin is removed by autocropping.
 </ul>
 
 \section org_mitk_views_segmentationof3dtimages Segmentation of 3D+t images
 
 For segmentation of 3D+t images, some tools give you the option to choose between creating dynamic and static masks.
 <ul>
   <li> Dynamic masks can be created on each time frame individually.
   <li> Static masks will be defined on one time frame and will be the same for all other time frames.
 </ul>
 
 In general, segmentation is applied on the time frame that is selected when execution is performed.
 If you alter the time frame, the segmentation preview is adapted.
 
 \section org_mitk_views_segmentationtechnicaldetail Technical information for developers
 
 For technical specifications see \subpage QmitkSegmentationTechnicalPage and for information on the extensions of the tools system \subpage toolextensions.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_nnUNet_Advanced.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_nnUNet_Advanced.png
index 22c26d4852..6c8eb921d8 100644
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_nnUNet_Advanced.png and b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_nnUNet_Advanced.png differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/files.cmake b/Plugins/org.mitk.gui.qt.segmentation/files.cmake
index bb27b67836..584a0cf103 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/files.cmake
+++ b/Plugins/org.mitk.gui.qt.segmentation/files.cmake
@@ -1,81 +1,87 @@
 set(SRC_CPP_FILES
   QmitkSegmentationPreferencePage.cpp
+  QmitkNewSegmentationDialog.cpp
+  QmitkLabelSetWidget.cpp
 )
 
 set(INTERNAL_CPP_FILES
   mitkPluginActivator.cpp
   QmitkSegmentationView.cpp
   QmitkAutocropAction.cpp
   QmitkAutocropLabelSetImageAction.cpp
   QmitkCreatePolygonModelAction.cpp
   QmitkLoadMultiLabelPresetAction.cpp
   QmitkSaveMultiLabelPresetAction.cpp
   Common/QmitkDataSelectionWidget.cpp
   Common/QmitkLabelsWidget.cpp
   Common/QmitkLayersWidget.cpp
   SegmentationUtilities/QmitkSegmentationUtilitiesView.cpp
   SegmentationUtilities/QmitkSegmentationUtilityWidget.cpp
   SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.cpp
   SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.cpp
   SegmentationUtilities/ContourModelToImage/QmitkContourModelToImageWidget.cpp
   SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.cpp
   SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.cpp
 )
 
 set(UI_FILES
   src/QmitkSegmentationPreferencePageControls.ui
+  src/QmitkNewSegmentationDialog.ui
+  src/QmitkLabelSetWidgetControls.ui
   src/internal/QmitkSegmentationViewControls.ui
   src/internal/Common/QmitkDataSelectionWidgetControls.ui
   src/internal/Common/QmitkLabelsWidgetControls.ui
   src/internal/Common/QmitkLayersWidgetControls.ui
   src/internal/SegmentationUtilities/QmitkSegmentationUtilitiesViewControls.ui
   src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidgetControls.ui
   src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidgetControls.ui
   src/internal/SegmentationUtilities/ContourModelToImage/QmitkContourModelToImageWidgetControls.ui
   src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidgetControls.ui
   src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidgetControls.ui
 )
 
 set(MOC_H_FILES
   src/QmitkSegmentationPreferencePage.h
+  src/QmitkNewSegmentationDialog.h
+  src/QmitkLabelSetWidget.h
   src/internal/mitkPluginActivator.h
   src/internal/QmitkSegmentationView.h
   src/internal/QmitkAutocropAction.h
   src/internal/QmitkAutocropLabelSetImageAction.h
   src/internal/QmitkCreatePolygonModelAction.h
   src/internal/QmitkLoadMultiLabelPresetAction.h
   src/internal/QmitkSaveMultiLabelPresetAction.h
   src/internal/Common/QmitkDataSelectionWidget.h
   src/internal/Common/QmitkLabelsWidget.h
   src/internal/Common/QmitkLayersWidget.h
   src/internal/SegmentationUtilities/QmitkSegmentationUtilitiesView.h
   src/internal/SegmentationUtilities/QmitkSegmentationUtilityWidget.h
   src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.h
   src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.h
   src/internal/SegmentationUtilities/ContourModelToImage/QmitkContourModelToImageWidget.h
   src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.h
   src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.h
 )
 
 set(CACHED_RESOURCE_FILES
   resources/segmentation.svg
   resources/segmentation_utilities.svg
   plugin.xml
 )
 
 set(QRC_FILES
   resources/segmentation.qrc
   resources/SegmentationUtilities.qrc
   resources/BooleanOperationsWidget.qrc
   resources/MorphologicalOperationsWidget.qrc
 )
 
 set(CPP_FILES)
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
diff --git a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.cpp
similarity index 85%
rename from Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp
rename to Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.cpp
index 09a09a2dd9..0742129dfa 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.cpp
@@ -1,1291 +1,1147 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkLabelSetWidget.h"
 
 // mitk
 #include <mitkAutoCropImageFilter.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 #include <mitkLabelSetImage.h>
 #include <mitkLabelSetImageToSurfaceThreadedFilter.h>
 #include <mitkRenderingManager.h>
 #include <mitkShowSegmentationAsSurface.h>
 #include <mitkSliceBasedInterpolationController.h>
 #include <mitkStatusBar.h>
 #include <mitkSurfaceBasedInterpolationController.h>
 #include <mitkToolManagerProvider.h>
 
 // Qmitk
 #include <QmitkDataStorageComboBox.h>
 #include <QmitkNewSegmentationDialog.h>
 #include <QmitkStyleManager.h>
 
 // Qt
 #include <QColorDialog>
 #include <QCompleter>
 #include <QDateTime>
 #include <QFileDialog>
 #include <QMenu>
 #include <QMessageBox>
 #include <QPushButton>
 #include <QStringListModel>
 #include <QWidgetAction>
 
 // itk
 #include <itksys/SystemTools.hxx>
 
 QmitkLabelSetWidget::QmitkLabelSetWidget(QWidget *parent)
   : QWidget(parent), m_DataStorage(nullptr), m_Completer(nullptr), m_ToolManager(nullptr), m_ProcessingManualSelection(false)
 {
   m_Controls.setupUi(this);
 
   m_ColorSequenceRainbow.GoToBegin();
 
   m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
 
   m_Controls.m_LabelSearchBox->setAlwaysShowClearIcon(true);
   m_Controls.m_LabelSearchBox->setShowSearchIcon(true);
 
   QStringList completionList;
   completionList << "";
   m_Completer = new QCompleter(completionList, this);
   m_Completer->setCaseSensitivity(Qt::CaseInsensitive);
   m_Controls.m_LabelSearchBox->setCompleter(m_Completer);
 
   connect(m_Controls.m_LabelSearchBox, SIGNAL(returnPressed()), this, SLOT(OnSearchLabel()));
 
   QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
   completeModel->setStringList(GetLabelStringList());
 
   m_Controls.m_LabelSearchBox->setEnabled(false);
 
   m_Controls.m_lblCaption->setText("");
 
   InitializeTableWidget();
 }
 
 QmitkLabelSetWidget::~QmitkLabelSetWidget() {}
 
 void QmitkLabelSetWidget::OnTableViewContextMenuRequested(const QPoint & /*pos*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
 
   if (-1 == pixelValue)
     return;
 
   QMenu *menu = new QMenu(m_Controls.m_LabelSetTableWidget);
 
   if (m_Controls.m_LabelSetTableWidget->selectedItems().size() > 1)
   {
     QAction *mergeAction = new QAction(QIcon(":/Qmitk/MergeLabels.png"), "Merge selection on current label", this);
     mergeAction->setEnabled(true);
     QObject::connect(mergeAction, SIGNAL(triggered(bool)), this, SLOT(OnMergeLabels(bool)));
     menu->addAction(mergeAction);
 
     QAction *removeLabelsAction = new QAction(QIcon(":/Qmitk/RemoveLabel.png"), "Remove selected labels", this);
     removeLabelsAction->setEnabled(true);
     QObject::connect(removeLabelsAction, SIGNAL(triggered(bool)), this, SLOT(OnRemoveLabels(bool)));
     menu->addAction(removeLabelsAction);
 
     QAction *eraseLabelsAction = new QAction(QIcon(":/Qmitk/EraseLabel.png"), "Erase selected labels", this);
     eraseLabelsAction->setEnabled(true);
     QObject::connect(eraseLabelsAction, SIGNAL(triggered(bool)), this, SLOT(OnEraseLabels(bool)));
     menu->addAction(eraseLabelsAction);
-
-    /*QAction* combineAndCreateSurfaceAction =
-      new QAction(QIcon(":/Qmitk/CreateSurface.png"), "Combine and create a surface", this);
-    combineAndCreateSurfaceAction->setEnabled(true);
-    QObject::connect(
-      combineAndCreateSurfaceAction, SIGNAL(triggered(bool)), this, SLOT(OnCombineAndCreateSurface(bool)));*/
-    // menu->addAction(combineAndCreateSurfaceAction); Not implemented
-
-    /*QAction* createMasksAction =
-      new QAction(QIcon(":/Qmitk/CreateMask.png"), "Create a mask for each selected label", this);
-    createMasksAction->setEnabled(true);
-    QObject::connect(createMasksAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateMasks(bool)));*/
-    // menu->addAction(createMasksAction); Not implemented
-
-    /*QAction* combineAndCreateMaskAction =
-      new QAction(QIcon(":/Qmitk/CreateMask.png"), "Combine and create a mask", this);
-    combineAndCreateMaskAction->setEnabled(true);
-    QObject::connect(combineAndCreateMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCombineAndCreateMask(bool)));*/
-    // menu->addAction(combineAndCreateMaskAction); Not implemented
   }
   else
   {
     QAction *renameAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "Rename...", this);
     renameAction->setEnabled(true);
     QObject::connect(renameAction, SIGNAL(triggered(bool)), this, SLOT(OnRenameLabel(bool)));
     menu->addAction(renameAction);
 
     QAction *removeAction = new QAction(QIcon(":/Qmitk/RemoveLabel.png"), "Remove...", this);
     removeAction->setEnabled(true);
     QObject::connect(removeAction, SIGNAL(triggered(bool)), this, SLOT(OnRemoveLabel(bool)));
     menu->addAction(removeAction);
 
     QAction *eraseAction = new QAction(QIcon(":/Qmitk/EraseLabel.png"), "Erase...", this);
     eraseAction->setEnabled(true);
     QObject::connect(eraseAction, SIGNAL(triggered(bool)), this, SLOT(OnEraseLabel(bool)));
     menu->addAction(eraseAction);
 
     QAction *randomColorAction = new QAction(QIcon(":/Qmitk/RandomColor.png"), "Random color", this);
     randomColorAction->setEnabled(true);
     QObject::connect(randomColorAction, SIGNAL(triggered(bool)), this, SLOT(OnRandomColor(bool)));
     menu->addAction(randomColorAction);
 
     QAction *viewOnlyAction = new QAction(QIcon(":/Qmitk/visible.png"), "View only", this);
     viewOnlyAction->setEnabled(true);
     QObject::connect(viewOnlyAction, SIGNAL(triggered(bool)), this, SLOT(OnSetOnlyActiveLabelVisible(bool)));
     menu->addAction(viewOnlyAction);
 
     QAction *viewAllAction = new QAction(QIcon(":/Qmitk/visible.png"), "View all", this);
     viewAllAction->setEnabled(true);
     QObject::connect(viewAllAction, SIGNAL(triggered(bool)), this, SLOT(OnSetAllLabelsVisible(bool)));
     menu->addAction(viewAllAction);
 
     QAction *hideAllAction = new QAction(QIcon(":/Qmitk/invisible.png"), "Hide all", this);
     hideAllAction->setEnabled(true);
     QObject::connect(hideAllAction, SIGNAL(triggered(bool)), this, SLOT(OnSetAllLabelsInvisible(bool)));
     menu->addAction(hideAllAction);
 
     QAction *lockAllAction = new QAction(QIcon(":/Qmitk/lock.png"), "Lock all", this);
     lockAllAction->setEnabled(true);
     QObject::connect(lockAllAction, SIGNAL(triggered(bool)), this, SLOT(OnLockAllLabels(bool)));
     menu->addAction(lockAllAction);
 
     QAction *unlockAllAction = new QAction(QIcon(":/Qmitk/unlock.png"), "Unlock all", this);
     unlockAllAction->setEnabled(true);
     QObject::connect(unlockAllAction, SIGNAL(triggered(bool)), this, SLOT(OnUnlockAllLabels(bool)));
     menu->addAction(unlockAllAction);
 
     QAction *createSurfaceAction = new QAction(QIcon(":/Qmitk/CreateSurface.png"), "Create surface", this);
     createSurfaceAction->setEnabled(true);
     createSurfaceAction->setMenu(new QMenu());
 
     QAction *tmp1 = createSurfaceAction->menu()->addAction(QString("Detailed"));
     QAction *tmp2 = createSurfaceAction->menu()->addAction(QString("Smoothed"));
 
     QObject::connect(tmp1, SIGNAL(triggered(bool)), this, SLOT(OnCreateDetailedSurface(bool)));
     QObject::connect(tmp2, SIGNAL(triggered(bool)), this, SLOT(OnCreateSmoothedSurface(bool)));
 
     menu->addAction(createSurfaceAction);
 
     QAction *createMaskAction = new QAction(QIcon(":/Qmitk/CreateMask.png"), "Create mask", this);
     createMaskAction->setEnabled(true);
     QObject::connect(createMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateMask(bool)));
 
     menu->addAction(createMaskAction);
 
     QAction *createCroppedMaskAction = new QAction(QIcon(":/Qmitk/CreateMask.png"), "Create cropped mask", this);
     createCroppedMaskAction->setEnabled(true);
     QObject::connect(createCroppedMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateCroppedMask(bool)));
 
-    //    QAction* importAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "Import...", this );
-    //    importAction->setEnabled(true);
-    //    QObject::connect( importAction, SIGNAL( triggered(bool) ), this, SLOT( OnImportSegmentationSession(bool) ) );
-    //    menu->addAction(importAction);
-
     menu->addAction(createCroppedMaskAction);
 
     QSlider *opacitySlider = new QSlider;
     opacitySlider->setMinimum(0);
     opacitySlider->setMaximum(100);
     opacitySlider->setOrientation(Qt::Horizontal);
     QObject::connect(opacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OnOpacityChanged(int)));
 
     QLabel *_OpacityLabel = new QLabel("Opacity: ");
     QVBoxLayout *_OpacityWidgetLayout = new QVBoxLayout;
     _OpacityWidgetLayout->setContentsMargins(4, 4, 4, 4);
     _OpacityWidgetLayout->addWidget(_OpacityLabel);
     _OpacityWidgetLayout->addWidget(opacitySlider);
     QWidget *_OpacityWidget = new QWidget;
     _OpacityWidget->setLayout(_OpacityWidgetLayout);
 
     QWidgetAction *OpacityAction = new QWidgetAction(this);
     OpacityAction->setDefaultWidget(_OpacityWidget);
     //  QObject::connect( m_OpacityAction, SIGNAL( changed() ), this, SLOT( OpacityActionChanged() ) );
     auto workingImage = this->GetWorkingImage();
     auto activeLayer = workingImage->GetActiveLayer();
     auto label = workingImage->GetLabel(pixelValue, activeLayer);
 
     if (nullptr != label)
     {
       auto opacity = label->GetOpacity();
       opacitySlider->setValue(static_cast<int>(opacity * 100));
     }
 
     menu->addAction(OpacityAction);
   }
   menu->popup(QCursor::pos());
 }
 
 void QmitkLabelSetWidget::OnUnlockAllLabels(bool /*value*/)
 {
   GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsLocked(false);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::OnLockAllLabels(bool /*value*/)
 {
   GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsLocked(true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::OnSetAllLabelsVisible(bool /*value*/)
 {
   GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsVisible(true);
   UpdateAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnSetAllLabelsInvisible(bool /*value*/)
 {
   GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsVisible(false);
   UpdateAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnSetOnlyActiveLabelVisible(bool /*value*/)
 {
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   int pixelValue = GetPixelValueOfSelectedItem();
 
   workingImage->GetActiveLabelSet()->SetAllLabelsVisible(false);
   workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->SetVisible(true);
 
   workingImage->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
 
   this->WaitCursorOn();
 
   const mitk::Point3D &pos =
     workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetCenterOfMassCoordinates();
   this->WaitCursorOff();
   if (pos.GetVnlVector().max_value() > 0.0)
   {
     emit goToLabel(pos);
   }
 
   UpdateAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnEraseLabel(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   QString question = "Do you really want to erase the contents of label \"";
   question.append(
     QString::fromStdString(GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetName()));
   question.append("\"?");
 
   QMessageBox::StandardButton answerButton =
     QMessageBox::question(this, "Erase label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     this->WaitCursorOn();
     GetWorkingImage()->EraseLabel(pixelValue);
     this->WaitCursorOff();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkLabelSetWidget::OnRemoveLabel(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   QString question = "Do you really want to remove label \"";
   question.append(
     QString::fromStdString(GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetName()));
   question.append("\"?");
 
   QMessageBox::StandardButton answerButton =
     QMessageBox::question(this, "Remove label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     this->WaitCursorOn();
-    GetWorkingImage()->GetActiveLabelSet()->RemoveLabel(pixelValue);
-    GetWorkingImage()->EraseLabel(pixelValue);
+    GetWorkingImage()->RemoveLabel(pixelValue, GetWorkingImage()->GetActiveLayer());
     this->WaitCursorOff();
   }
 
   ResetAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnRenameLabel(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
-  QmitkNewSegmentationDialog dialog(this);
-  dialog.setWindowTitle("Rename Label");
-  dialog.SetSuggestionList(m_OrganColors);
+  QmitkNewSegmentationDialog dialog(this, this->GetWorkingImage(), QmitkNewSegmentationDialog::RenameLabel);
   dialog.SetColor(GetWorkingImage()->GetActiveLabelSet()->GetLabel(pixelValue)->GetColor());
-  dialog.SetSegmentationName(
-    QString::fromStdString(GetWorkingImage()->GetActiveLabelSet()->GetLabel(pixelValue)->GetName()));
+  dialog.SetName(QString::fromStdString(GetWorkingImage()->GetActiveLabelSet()->GetLabel(pixelValue)->GetName()));
 
   if (dialog.exec() == QDialog::Rejected)
   {
     return;
   }
-  QString segmentationName = dialog.GetSegmentationName();
+  QString segmentationName = dialog.GetName();
   if (segmentationName.isEmpty())
   {
     segmentationName = "Unnamed";
   }
 
   GetWorkingImage()->GetActiveLabelSet()->RenameLabel(pixelValue, segmentationName.toStdString(), dialog.GetColor());
   GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
 
   UpdateAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnCombineAndCreateMask(bool /*value*/)
 {
   m_Controls.m_LabelSetTableWidget->selectedRanges();
   // ...to do... //
 }
 
 void QmitkLabelSetWidget::OnCreateMasks(bool /*value*/)
 {
   m_Controls.m_LabelSetTableWidget->selectedRanges();
   // ..to do.. //
 }
 
 void QmitkLabelSetWidget::OnCombineAndCreateSurface(bool /*value*/)
 {
   m_Controls.m_LabelSetTableWidget->selectedRanges();
   // ..to do.. //
 }
 
 void QmitkLabelSetWidget::OnEraseLabels(bool /*value*/)
 {
   QString question = "Do you really want to erase the selected labels?";
 
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     this, "Erase selected labels", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
     if (ranges.isEmpty())
       return;
 
     std::vector<mitk::Label::PixelType> VectorOfLablePixelValues;
     foreach (QTableWidgetSelectionRange a, ranges)
       for (int i = a.topRow(); i <= a.bottomRow(); i++)
         VectorOfLablePixelValues.push_back(m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt());
 
     this->WaitCursorOn();
-    GetWorkingImage()->EraseLabels(VectorOfLablePixelValues, GetWorkingImage()->GetActiveLayer());
+    GetWorkingImage()->EraseLabels(VectorOfLablePixelValues);
     this->WaitCursorOff();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkLabelSetWidget::OnRemoveLabels(bool /*value*/)
 {
   QString question = "Do you really want to remove the selected labels?";
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     this, "Remove selected labels", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
     if (ranges.isEmpty())
     {
       return;
     }
 
     std::vector<mitk::Label::PixelType> VectorOfLablePixelValues;
     foreach (QTableWidgetSelectionRange a, ranges)
     {
       for (int i = a.topRow(); i <= a.bottomRow(); ++i)
       {
         VectorOfLablePixelValues.push_back(m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt());
       }
     }
 
     this->WaitCursorOn();
     GetWorkingImage()->RemoveLabels(VectorOfLablePixelValues, GetWorkingImage()->GetActiveLayer());
     this->WaitCursorOff();
   }
 
   ResetAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnMergeLabels(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   QString question = "Do you really want to merge selected labels into \"";
   question.append(
     QString::fromStdString(GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetName()));
   question.append("\"?");
 
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     this, "Merge selected label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
     if (ranges.isEmpty())
     {
       return;
     }
 
     std::vector<mitk::Label::PixelType> vectorOfSourcePixelValues;
     foreach (QTableWidgetSelectionRange a, ranges)
     {
       for (int i = a.topRow(); i <= a.bottomRow(); ++i)
       {
         vectorOfSourcePixelValues.push_back(m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt());
       }
     }
 
     this->WaitCursorOn();
     GetWorkingImage()->MergeLabels(pixelValue, vectorOfSourcePixelValues, GetWorkingImage()->GetActiveLayer());
     this->WaitCursorOff();
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkLabelSetWidget::OnLockedButtonClicked()
 {
   int row = -1;
   for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
   {
     if (sender() == m_Controls.m_LabelSetTableWidget->cellWidget(i, LOCKED_COL))
     {
       row = i;
     }
   }
   if (row >= 0 && row < m_Controls.m_LabelSetTableWidget->rowCount())
   {
     int pixelValue = m_Controls.m_LabelSetTableWidget->item(row, 0)->data(Qt::UserRole).toInt();
     GetWorkingImage()
       ->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())
       ->SetLocked(!GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetLocked());
   }
 }
 
 void QmitkLabelSetWidget::OnVisibleButtonClicked()
 {
   int row = -1;
   for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
   {
     if (sender() == m_Controls.m_LabelSetTableWidget->cellWidget(i, VISIBLE_COL))
     {
       row = i;
       break;
     }
   }
 
   if (row >= 0 && row < m_Controls.m_LabelSetTableWidget->rowCount())
   {
     QTableWidgetItem *item = m_Controls.m_LabelSetTableWidget->item(row, 0);
     int pixelValue = item->data(Qt::UserRole).toInt();
     GetWorkingImage()
       ->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())
       ->SetVisible(!GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetVisible());
     GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::OnColorButtonClicked()
 {
   int row = -1;
   for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
   {
     if (sender() == m_Controls.m_LabelSetTableWidget->cellWidget(i, COLOR_COL))
     {
       row = i;
     }
   }
 
   if (row >= 0 && row < m_Controls.m_LabelSetTableWidget->rowCount())
   {
     int pixelValue = m_Controls.m_LabelSetTableWidget->item(row, 0)->data(Qt::UserRole).toInt();
     const mitk::Color &color = GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetColor();
     QColor initial(color.GetRed() * 255, color.GetGreen() * 255, color.GetBlue() * 255);
     QColor qcolor = QColorDialog::getColor(initial, nullptr, QString("Change color"));
     if (!qcolor.isValid())
     {
       return;
     }
 
     QPushButton *button = static_cast<QPushButton *>(m_Controls.m_LabelSetTableWidget->cellWidget(row, COLOR_COL));
     if (!button)
     {
       return;
     }
 
     button->setAutoFillBackground(true);
 
     QString styleSheet = "background-color:rgb(";
     styleSheet.append(QString::number(qcolor.red()));
     styleSheet.append(",");
     styleSheet.append(QString::number(qcolor.green()));
     styleSheet.append(",");
     styleSheet.append(QString::number(qcolor.blue()));
     styleSheet.append("); border: 0;");
     button->setStyleSheet(styleSheet);
 
     mitk::Color newColor;
     newColor.SetRed(qcolor.red() / 255.0);
     newColor.SetGreen(qcolor.green() / 255.0);
     newColor.SetBlue(qcolor.blue() / 255.0);
 
     GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->SetColor(newColor);
 
     GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
   }
 }
 
 void QmitkLabelSetWidget::OnRandomColor(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   GetWorkingImage()
     ->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())
     ->SetColor(m_ColorSequenceRainbow.GetNextColor());
   GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
   UpdateAllTableWidgetItems();
 }
 
-void QmitkLabelSetWidget::SetOrganColors(const QStringList &organColors)
-{
-  m_OrganColors = organColors;
-}
-
 void QmitkLabelSetWidget::OnActiveLabelChanged(int pixelValue)
 {
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   assert(workingImage);
   workingImage->GetActiveLabelSet()->SetActiveLabel(pixelValue);
   // MITK_INFO << "Active Label set to << " << pixelValue;
 
   mitk::SurfaceBasedInterpolationController *interpolator = mitk::SurfaceBasedInterpolationController::GetInstance();
   if (interpolator)
   {
     interpolator->SetActiveLabel(pixelValue);
   }
 
   workingImage->Modified();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::OnItemClicked(QTableWidgetItem *item)
 {
   if (!item)
     return;
 
   int pixelValue = item->data(Qt::UserRole).toInt();
 
   QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
   if (!ranges.empty() && ranges.back().rowCount() == 1)
   {
     m_ProcessingManualSelection = true;
     OnActiveLabelChanged(pixelValue);
     m_ProcessingManualSelection = false;
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkLabelSetWidget::OnItemDoubleClicked(QTableWidgetItem *item)
 {
   if (!item)
     return;
 
   int pixelValue = item->data(Qt::UserRole).toInt();
   // OnItemClicked(item); <<-- Double click first call OnItemClicked
   WaitCursorOn();
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   workingImage->UpdateCenterOfMass(pixelValue, workingImage->GetActiveLayer());
   const mitk::Point3D &pos =
     workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetCenterOfMassCoordinates();
   WaitCursorOff();
   if (pos.GetVnlVector().max_value() > 0.0)
   {
     emit goToLabel(pos);
   }
 
   workingImage->Modified();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::SelectLabelByPixelValue(mitk::Label::PixelType pixelValue)
 {
   if (m_ProcessingManualSelection || !GetWorkingImage()->ExistLabel(pixelValue))
     return;
 
   for (int row = 0; row < m_Controls.m_LabelSetTableWidget->rowCount(); row++)
   {
     if (m_Controls.m_LabelSetTableWidget->item(row, 0)->data(Qt::UserRole).toInt() == pixelValue)
     {
       m_Controls.m_LabelSetTableWidget->clearSelection();
       m_Controls.m_LabelSetTableWidget->selectRow(row);
       m_Controls.m_LabelSetTableWidget->scrollToItem(m_Controls.m_LabelSetTableWidget->item(row, 0));
       return;
     }
   }
 }
 
 void QmitkLabelSetWidget::InsertTableWidgetItem(mitk::Label *label)
 {
   const mitk::Color &color = label->GetColor();
 
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color[0] * 255));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[1] * 255));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[2] * 255));
   styleSheet.append("); border: 0;");
 
   QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
   int colWidth = (tableWidget->columnWidth(NAME_COL) < 180) ? 180 : tableWidget->columnWidth(NAME_COL) - 2;
   QString text = fontMetrics().elidedText(label->GetName().c_str(), Qt::ElideMiddle, colWidth);
   QTableWidgetItem *nameItem = new QTableWidgetItem(text);
   nameItem->setTextAlignment(Qt::AlignCenter | Qt::AlignLeft);
   // ---!---
   // IMPORTANT: ADD PIXELVALUE TO TABLEWIDGETITEM.DATA
   nameItem->setData(Qt::UserRole, QVariant(label->GetValue()));
   // ---!---
 
   QPushButton *pbColor = new QPushButton(tableWidget);
   pbColor->setFixedSize(24, 24);
   pbColor->setCheckable(false);
   pbColor->setAutoFillBackground(true);
   pbColor->setToolTip("Change label color");
   pbColor->setStyleSheet(styleSheet);
 
   connect(pbColor, SIGNAL(clicked()), this, SLOT(OnColorButtonClicked()));
 
   QString transparentStyleSheet = QLatin1String("background-color: transparent; border: 0;");
 
   QPushButton *pbLocked = new QPushButton(tableWidget);
   pbLocked->setFixedSize(24, 24);
   QIcon *iconLocked = new QIcon();
   auto lockIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg"));
   auto unlockIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg"));
   iconLocked->addPixmap(lockIcon.pixmap(64), QIcon::Normal, QIcon::Off);
   iconLocked->addPixmap(unlockIcon.pixmap(64), QIcon::Normal, QIcon::On);
   pbLocked->setIcon(*iconLocked);
   pbLocked->setIconSize(QSize(24, 24));
   pbLocked->setCheckable(true);
   pbLocked->setToolTip("Lock/unlock label");
   pbLocked->setChecked(!label->GetLocked());
   pbLocked->setStyleSheet(transparentStyleSheet);
 
   connect(pbLocked, SIGNAL(clicked()), this, SLOT(OnLockedButtonClicked()));
 
   QPushButton *pbVisible = new QPushButton(tableWidget);
   pbVisible->setFixedSize(24, 24);
   pbVisible->setAutoRepeat(false);
   QIcon *iconVisible = new QIcon();
   auto visibleIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg"));
   auto invisibleIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/invisible.svg"));
   iconVisible->addPixmap(visibleIcon.pixmap(64), QIcon::Normal, QIcon::Off);
   iconVisible->addPixmap(invisibleIcon.pixmap(64), QIcon::Normal, QIcon::On);
   pbVisible->setIcon(*iconVisible);
   pbVisible->setIconSize(QSize(24, 24));
   pbVisible->setCheckable(true);
   pbVisible->setToolTip("Show/hide label");
   pbVisible->setChecked(!label->GetVisible());
   pbVisible->setStyleSheet(transparentStyleSheet);
 
   connect(pbVisible, SIGNAL(clicked()), this, SLOT(OnVisibleButtonClicked()));
 
   int row = tableWidget->rowCount();
   tableWidget->insertRow(row);
   tableWidget->setRowHeight(row, 24);
   tableWidget->setItem(row, 0, nameItem);
   tableWidget->setCellWidget(row, 1, pbLocked);
   tableWidget->setCellWidget(row, 2, pbColor);
   tableWidget->setCellWidget(row, 3, pbVisible);
   tableWidget->selectRow(row);
 
   // m_LabelSetImage->SetActiveLabel(label->GetPixelValue());
   // m_ToolManager->WorkingDataModified.Send();
   // emit activeLabelChanged(label->GetPixelValue());
 
   if (row == 0)
   {
     tableWidget->hideRow(row); // hide exterior label
   }
 }
 
 void QmitkLabelSetWidget::UpdateAllTableWidgetItems()
 {
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   if (!workingImage)
     return;
 
   // add all labels
   QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
   m_LabelStringList.clear();
   for (int i = 0; i < tableWidget->rowCount(); ++i)
   {
     UpdateTableWidgetItem(tableWidget->item(i, 0));
     m_LabelStringList.append(tableWidget->item(i, 0)->text());
   }
 
   OnLabelListModified(m_LabelStringList);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::UpdateTableWidgetItem(QTableWidgetItem *item)
 {
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   mitk::Label *label = workingImage->GetLabel(item->data(Qt::UserRole).toInt(), workingImage->GetActiveLayer());
 
   const mitk::Color &color = label->GetColor();
 
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color[0] * 255));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[1] * 255));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[2] * 255));
   styleSheet.append("); border: 0;");
 
   QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
   int colWidth = (tableWidget->columnWidth(NAME_COL) < 180) ? 180 : tableWidget->columnWidth(NAME_COL) - 2;
   QString text = fontMetrics().elidedText(label->GetName().c_str(), Qt::ElideMiddle, colWidth);
   item->setText(text);
 
   QPushButton *pbLocked = dynamic_cast<QPushButton *>(tableWidget->cellWidget(item->row(), 1));
   pbLocked->setChecked(!label->GetLocked());
 
   QPushButton *pbColor = dynamic_cast<QPushButton *>(tableWidget->cellWidget(item->row(), 2));
   pbColor->setStyleSheet(styleSheet);
 
   QPushButton *pbVisible = dynamic_cast<QPushButton *>(tableWidget->cellWidget(item->row(), 3));
   pbVisible->setChecked(!label->GetVisible());
 
   if (item->row() == 0)
   {
     tableWidget->hideRow(item->row()); // hide exterior label
   }
 }
 
 void QmitkLabelSetWidget::ResetAllTableWidgetItems()
 {
   QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
   // remove all rows
   while (tableWidget->rowCount())
   {
     tableWidget->removeRow(0);
   }
 
   mitk::DataNode * workingNode = GetWorkingNode();
   auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   if (nullptr == workingImage)
   {
     return;
   }
 
   // add all labels
   m_LabelStringList.clear();
 
   mitk::LabelSet::LabelContainerConstIteratorType it = workingImage->GetActiveLabelSet()->IteratorConstBegin();
   mitk::LabelSet::LabelContainerConstIteratorType end = workingImage->GetActiveLabelSet()->IteratorConstEnd();
 
   int pixelValue = -1;
   while (it != end)
   {
     InsertTableWidgetItem(it->second);
-    if (workingImage->GetActiveLabel() == it->second) // get active
+    if (workingImage->GetActiveLabel(workingImage->GetActiveLayer()) == it->second) // get active
       pixelValue = it->first;
     m_LabelStringList.append(QString(it->second->GetName().c_str()));
     it++;
   }
 
   SelectLabelByPixelValue(pixelValue);
 
   OnLabelListModified(m_LabelStringList);
 
   std::stringstream captionText;
   captionText << "Number of labels: " << workingImage->GetNumberOfLabels(workingImage->GetActiveLayer()) - 1;
   m_Controls.m_lblCaption->setText(captionText.str().c_str());
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   emit LabelSetWidgetReset();
 }
 
 int QmitkLabelSetWidget::GetPixelValueOfSelectedItem()
 {
   if (m_Controls.m_LabelSetTableWidget->currentItem())
   {
     return m_Controls.m_LabelSetTableWidget->currentItem()->data(Qt::UserRole).toInt();
   }
   return -1;
 }
 
 QStringList &QmitkLabelSetWidget::GetLabelStringList()
 {
   return m_LabelStringList;
 }
 
 void QmitkLabelSetWidget::InitializeTableWidget()
 {
   QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
 
   tableWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
   tableWidget->setTabKeyNavigation(false);
   tableWidget->setAlternatingRowColors(false);
   tableWidget->setFocusPolicy(Qt::NoFocus);
   tableWidget->setColumnCount(4);
   tableWidget->resizeColumnToContents(NAME_COL);
   tableWidget->setColumnWidth(LOCKED_COL, 25);
   tableWidget->setColumnWidth(COLOR_COL, 25);
   tableWidget->setColumnWidth(VISIBLE_COL, 25);
   tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
   tableWidget->setContextMenuPolicy(Qt::CustomContextMenu);
   tableWidget->horizontalHeader()->hide();
   tableWidget->setSortingEnabled(false);
   tableWidget->verticalHeader()->hide();
   tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
   connect(tableWidget, SIGNAL(itemClicked(QTableWidgetItem *)), this, SLOT(OnItemClicked(QTableWidgetItem *)));
   connect(
     tableWidget, SIGNAL(itemDoubleClicked(QTableWidgetItem *)), this, SLOT(OnItemDoubleClicked(QTableWidgetItem *)));
   connect(tableWidget,
           SIGNAL(customContextMenuRequested(const QPoint &)),
           this,
           SLOT(OnTableViewContextMenuRequested(const QPoint &)));
-
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(activeLabelChanged(int)), this, SLOT(OnActiveLabelChanged(int))
-  // );
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(importSegmentation()), this, SLOT( OnImportSegmentation()) );
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(importLabeledImage()), this, SLOT( OnImportLabeledImage()) );
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(renameLabel(int, const mitk::Color&, const std::string&)), this,
-  // SLOT(OnRenameLabel(int, const mitk::Color&, const std::string&)) );
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(createSurface(int, bool)), this, SLOT(OnCreateSurface(int, bool))
-  // );
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(toggleOutline(bool)), this, SLOT(OnToggleOutline(bool)) );
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(goToLabel(const mitk::Point3D&)), this, SIGNAL(goToLabel(const
-  // mitk::Point3D&)) );
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(combineAndCreateSurface( const QList<QTableWidgetSelectionRange>&
-  // )),
-  //    this, SLOT(OnCombineAndCreateSurface( const QList<QTableWidgetSelectionRange>&)) );
-
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(createMask(int)), this, SLOT(OnCreateMask(int)) );
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(createCroppedMask(int)), this, SLOT(OnCreateCroppedMask(int)) );
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(combineAndCreateMask( const QList<QTableWidgetSelectionRange>&
-  // )),
-  //    this, SLOT(OnCombineAndCreateMask( const QList<QTableWidgetSelectionRange>&)) );
 }
 
 void QmitkLabelSetWidget::OnOpacityChanged(int value)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   float opacity = static_cast<float>(value) / 100.0f;
   GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->SetOpacity(opacity);
   GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
 }
 
 void QmitkLabelSetWidget::setEnabled(bool enabled)
 {
   QWidget::setEnabled(enabled);
   UpdateControls();
 }
 
 void QmitkLabelSetWidget::SetDataStorage(mitk::DataStorage *storage)
 {
   m_DataStorage = storage;
 }
 
 void QmitkLabelSetWidget::OnSearchLabel()
 {
   std::string text = m_Controls.m_LabelSearchBox->text().toStdString();
   int pixelValue = -1;
   int row = -1;
   for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
   {
     if (m_Controls.m_LabelSetTableWidget->item(i, 0)->text().toStdString().compare(text) == 0)
     {
       pixelValue = m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt();
       row = i;
       break;
     }
   }
   if (pixelValue == -1)
   {
     return;
   }
 
   GetWorkingImage()->GetActiveLabelSet()->SetActiveLabel(pixelValue);
 
   QTableWidgetItem *nameItem = m_Controls.m_LabelSetTableWidget->item(row, NAME_COL);
   if (!nameItem)
   {
     return;
   }
 
   m_Controls.m_LabelSetTableWidget->clearSelection();
   m_Controls.m_LabelSetTableWidget->selectRow(row);
   m_Controls.m_LabelSetTableWidget->scrollToItem(nameItem);
 
   GetWorkingImage()->GetActiveLabelSet()->SetActiveLabel(pixelValue);
 
   this->WaitCursorOn();
   mitk::Point3D pos =
     GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetCenterOfMassCoordinates();
 
   m_ToolManager->WorkingDataChanged();
 
   if (pos.GetVnlVector().max_value() > 0.0)
   {
     emit goToLabel(pos);
   }
   else
   {
     GetWorkingImage()->UpdateCenterOfMass(pixelValue, GetWorkingImage()->GetActiveLayer());
     mitk::Point3D pos =
       GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetCenterOfMassCoordinates();
     emit goToLabel(pos);
   }
 
   this->WaitCursorOff();
 }
 
 void QmitkLabelSetWidget::OnLabelListModified(const QStringList &list)
 {
   QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
   completeModel->setStringList(list);
 }
 
 mitk::LabelSetImage *QmitkLabelSetWidget::GetWorkingImage()
 {
   mitk::DataNode *workingNode = GetWorkingNode();
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
   assert(workingImage);
   return workingImage;
 }
 
 mitk::DataNode *QmitkLabelSetWidget::GetWorkingNode()
 {
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
   return workingNode;
 }
 
 void QmitkLabelSetWidget::UpdateControls()
 {
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   bool hasWorkingData = (workingNode != nullptr);
 
   m_Controls.m_LabelSetTableWidget->setEnabled(hasWorkingData);
   m_Controls.m_LabelSearchBox->setEnabled(hasWorkingData);
 
   if (!hasWorkingData)
     return;
 
   QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
   completeModel->setStringList(GetLabelStringList());
 }
 
 void QmitkLabelSetWidget::OnCreateCroppedMask(bool)
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   mitk::Image::Pointer maskImage;
   int pixelValue = GetPixelValueOfSelectedItem();
   try
   {
     this->WaitCursorOn();
 
     mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
     cropFilter->SetInput(workingImage->CreateLabelMask(pixelValue));
     cropFilter->SetBackgroundValue(0);
     cropFilter->SetMarginFactor(1.15);
     cropFilter->Update();
 
     maskImage = cropFilter->GetOutput();
 
     this->WaitCursorOff();
   }
   catch (mitk::Exception &e)
   {
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
     return;
   }
 
   if (maskImage.IsNull())
   {
     QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
     return;
   }
 
   mitk::DataNode::Pointer maskNode = mitk::DataNode::New();
   std::string name = workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetName();
   name += "-mask";
   maskNode->SetName(name);
   maskNode->SetData(maskImage);
   maskNode->SetBoolProperty("binary", true);
   maskNode->SetBoolProperty("outline binary", true);
   maskNode->SetBoolProperty("outline binary shadow", true);
   maskNode->SetFloatProperty("outline width", 2.0);
   maskNode->SetColor(workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetColor());
   maskNode->SetOpacity(1.0);
 
   m_DataStorage->Add(maskNode, GetWorkingNode());
 }
 
 void QmitkLabelSetWidget::OnCreateMask(bool /*triggered*/)
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   mitk::Image::Pointer maskImage;
   int pixelValue = GetPixelValueOfSelectedItem();
   try
   {
     this->WaitCursorOn();
     maskImage = workingImage->CreateLabelMask(pixelValue);
     this->WaitCursorOff();
   }
   catch (mitk::Exception &e)
   {
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
     return;
   }
 
   if (maskImage.IsNull())
   {
     QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
     return;
   }
 
   mitk::DataNode::Pointer maskNode = mitk::DataNode::New();
   std::string name = workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetName();
   name += "-mask";
   maskNode->SetName(name);
   maskNode->SetData(maskImage);
   maskNode->SetBoolProperty("binary", true);
   maskNode->SetBoolProperty("outline binary", true);
   maskNode->SetBoolProperty("outline binary shadow", true);
   maskNode->SetFloatProperty("outline width", 2.0);
   maskNode->SetColor(workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetColor());
   maskNode->SetOpacity(1.0);
 
   m_DataStorage->Add(maskNode, GetWorkingNode());
 }
 
 void QmitkLabelSetWidget::OnToggleOutline(bool value)
 {
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   workingNode->SetBoolProperty("labelset.contour.active", value);
   workingNode->GetData()->Modified(); // fixme: workaround to force data-type rendering (and not only property-type)
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::OnCreateSmoothedSurface(bool /*triggered*/)
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode::Pointer workingNode = GetWorkingNode();
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   int pixelValue = GetPixelValueOfSelectedItem();
 
   mitk::LabelSetImageToSurfaceThreadedFilter::Pointer surfaceFilter = mitk::LabelSetImageToSurfaceThreadedFilter::New();
 
   itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer successCommand =
     itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
   successCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
 
   itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer errorCommand =
     itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
   errorCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
 
   mitk::DataNode::Pointer groupNode = workingNode;
   surfaceFilter->SetPointerParameter("Group node", groupNode);
   surfaceFilter->SetPointerParameter("Input", workingImage);
   surfaceFilter->SetParameter("RequestedLabel", pixelValue);
   surfaceFilter->SetParameter("Smooth", true);
   surfaceFilter->SetDataStorage(*m_DataStorage);
 
   mitk::StatusBar::GetInstance()->DisplayText("Surface creation is running in background...");
 
   try
   {
     surfaceFilter->StartAlgorithm();
   }
   catch (mitk::Exception &e)
   {
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this,
                              "Create Surface",
                              "Could not create a surface mesh out of the selected label. See error log for details.\n");
   }
 }
 
 void QmitkLabelSetWidget::OnCreateDetailedSurface(bool /*triggered*/)
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode::Pointer workingNode = GetWorkingNode();
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   int pixelValue = GetPixelValueOfSelectedItem();
 
   mitk::LabelSetImageToSurfaceThreadedFilter::Pointer surfaceFilter = mitk::LabelSetImageToSurfaceThreadedFilter::New();
 
   itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer successCommand =
     itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
   successCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
 
   itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer errorCommand =
     itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
   errorCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
 
   mitk::DataNode::Pointer groupNode = workingNode;
   surfaceFilter->SetPointerParameter("Group node", groupNode);
   surfaceFilter->SetPointerParameter("Input", workingImage);
   surfaceFilter->SetParameter("RequestedLabel", pixelValue);
   surfaceFilter->SetParameter("Smooth", false);
   surfaceFilter->SetDataStorage(*m_DataStorage);
 
   mitk::StatusBar::GetInstance()->DisplayText("Surface creation is running in background...");
 
   try
   {
     surfaceFilter->StartAlgorithm();
   }
   catch (mitk::Exception &e)
   {
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this,
                              "Create Surface",
                              "Could not create a surface mesh out of the selected label. See error log for details.\n");
   }
 }
 
-void QmitkLabelSetWidget::OnImportLabeledImage()
-{
-  /*
-    m_ToolManager->ActivateTool(-1);
-
-    mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
-    assert(referenceNode);
-
-    // Ask the user for a list of files to open
-    QStringList fileNames = QFileDialog::getOpenFileNames( this, "Open Image", m_LastFileOpenPath,
-                                                          mitk::CoreObjectFactory::GetInstance()->GetFileExtensions());
-
-    if (fileNames.empty())
-      return;
-
-    try
-    {
-      this->WaitCursorOn();
-      mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>( fileNames.front().toStdString() );
-      if (image.IsNull())
-      {
-        this->WaitCursorOff();
-        QMessageBox::information(this, "Import Labeled Image", "Could not load the selected segmentation.\n");
-        return;
-      }
-
-      mitk::LabelSetImage::Pointer newImage = mitk::LabelSetImage::New();
-      newImage->InitializeByLabeledImage(image);
-      this->WaitCursorOff();
-
-      mitk::DataNode::Pointer newNode = mitk::DataNode::New();
-      std::string newName = referenceNode->GetName();
-      newName += "-labels";
-      newNode->SetName(newName);
-      newNode->SetData(newImage);
-      m_DataStorage->Add(newNode, referenceNode);
-    }
-    catch (mitk::Exception & e)
-    {
-      this->WaitCursorOff();
-      MITK_ERROR << "Exception caught: " << e.GetDescription();
-      QMessageBox::information(this, "Import Labeled Image", "Could not load the selected segmentation. See error log
-    for details.\n");
-      return;
-     }
-
-    this->UpdateControls();
-
-    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-    */
-}
-
-void QmitkLabelSetWidget::OnImportSegmentation()
-{
-  /*
-    m_ToolManager->ActivateTool(-1);
-
-    mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
-    assert(workingNode);
-
-    mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>( workingNode->GetData() );
-    assert(workingImage);
-
-    std::string fileExtensions("Segmentation files (*.lset);;");
-    QString qfileName = QFileDialog::getOpenFileName(this, "Import Segmentation", m_LastFileOpenPath,
-    fileExtensions.c_str() );
-    if (qfileName.isEmpty() ) return;
-
-    mitk::NrrdLabelSetImageReader::Pointer reader = mitk::NrrdLabelSetImageReader::New();
-    reader->SetFileName(qfileName.toLatin1());
-
-    try
-    {
-      this->WaitCursorOn();
-      reader->Update();
-      mitk::LabelSetImage::Pointer newImage = reader->GetOutput();
-      workingImage->Concatenate(newImage);
-      this->WaitCursorOff();
-    }
-    catch ( mitk::Exception& e )
-    {
-      this->WaitCursorOff();
-      MITK_ERROR << "Exception caught: " << e.GetDescription();
-      QMessageBox::information(this, "Import Segmentation", "Could not import the selected segmentation session.\n See
-    error log for details.\n");
-    }
-  */
-  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-}
-
 void QmitkLabelSetWidget::WaitCursorOn()
 {
   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 }
 
 void QmitkLabelSetWidget::WaitCursorOff()
 {
   this->RestoreOverrideCursor();
 }
 
 void QmitkLabelSetWidget::RestoreOverrideCursor()
 {
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkLabelSetWidget::OnThreadedCalculationDone()
 {
   mitk::StatusBar::GetInstance()->Clear();
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.h
similarity index 91%
rename from Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h
rename to Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.h
index 12978f8022..9fb7a1c0e8 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.h
@@ -1,171 +1,165 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkLabelSetWidget_h
 #define QmitkLabelSetWidget_h
 
-#include "MitkSegmentationUIExports.h"
+#include <org_mitk_gui_qt_segmentation_Export.h>
 
-#include "mitkColorSequenceRainbow.h"
-#include "mitkLabel.h"
-#include "mitkNumericTypes.h"
+#include <mitkColorSequenceRainbow.h>
+#include <mitkLabel.h>
+#include <mitkNumericTypes.h>
 #include <ui_QmitkLabelSetWidgetControls.h>
 
 class QmitkDataStorageComboBox;
 class QCompleter;
 
 namespace mitk
 {
   class LabelSetImage;
   class LabelSet;
   class Label;
   class DataStorage;
   class ToolManager;
   class DataNode;
 }
 
-class MITKSEGMENTATIONUI_EXPORT QmitkLabelSetWidget : public QWidget
+class MITK_QT_SEGMENTATION QmitkLabelSetWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   explicit QmitkLabelSetWidget(QWidget *parent = nullptr);
   ~QmitkLabelSetWidget() override;
 
   void SetDataStorage(mitk::DataStorage *storage);
 
-  void SetOrganColors(const QStringList &organColors);
-
   void UpdateControls();
 
   virtual void setEnabled(bool enabled);
 
   QStringList &GetLabelStringList();
 
 signals:
 
   /// \brief Send a signal when it was requested to go to a label.
   void goToLabel(const mitk::Point3D &);
   void LabelSetWidgetReset();
 
 public slots:
 
   /**
   * @brief Updates the current labels in the label set widget table. For each label (widget item) the 'UpdateTableWidgetItem' is called.
   *
   *   Updating means setting the color box of the table, setting the column with and fill it with the label name.
   *   Furthermore the two push buttons for locking and showing/hiding the layer are checked/unchecked.
   *   This functions only changes the appearance of the table widget and no render window update is necessary.
   */
   void UpdateAllTableWidgetItems();
   /**
   * @brief Resets the current labels in the label set widget table. For each label a widget item is inserted into the table.
   *
   *   Resetting means removing all rows of the widget table and inserting new rows (labels) from the active label set (= layer) of the current working node.
   *   The currently active label is selected and 'Number of labels' is set.
   *   As this function is typically used after one label has been removed or the reference node has been changed (e.g.) the render windows have to be updated.
   */
   void ResetAllTableWidgetItems();
   void SelectLabelByPixelValue(mitk::Label::PixelType pixelValue);
 
 private slots:
 
   // LabelSet dependent
   void OnOpacityChanged(int);
   void OnUnlockAllLabels(bool);
   void OnLockAllLabels(bool);
   void OnSetAllLabelsVisible(bool);
   void OnSetAllLabelsInvisible(bool);
   void OnSetOnlyActiveLabelVisible(bool);
   void OnRandomColor(bool);
   void OnRemoveLabel(bool);
   void OnRemoveLabels(bool);
   void OnRenameLabel(bool);
   void OnLockedButtonClicked();
   void OnVisibleButtonClicked();
   void OnColorButtonClicked();
   void OnItemClicked(QTableWidgetItem *item);
   void OnItemDoubleClicked(QTableWidgetItem *item);
   void OnTableViewContextMenuRequested(const QPoint &);
   void InsertTableWidgetItem(mitk::Label *label);
   void UpdateTableWidgetItem(QTableWidgetItem *item);
   // reaction to "returnPressed" signal from ...
   void OnSearchLabel();
   // reaction to the button "Change Label"
   void OnActiveLabelChanged(int pixelValue);
 
   // LabelSetImage Dependet
   void OnCreateDetailedSurface(bool);
   void OnCreateSmoothedSurface(bool);
   // reaction to the signal "createMask" from QmitkLabelSetTableWidget
   void OnCreateMask(bool);
   void OnCreateMasks(bool);
   // reaction to the signal "createCroppedMask" from QmitkLabelSetTableWidget
   void OnCreateCroppedMask(bool);
   void OnCombineAndCreateMask(bool);
   void OnCombineAndCreateSurface(bool);
   void OnEraseLabel(bool);
   void OnEraseLabels(bool);
   void OnMergeLabels(bool);
-  // reaction to the button "Import Segmentation"
-  void OnImportSegmentation();
-  // reaction to the button "Import Labeled Image"
-  void OnImportLabeledImage();
 
   // reaction to signal "labelListModified" from QmitkLabelSetTableWidget
   void OnLabelListModified(const QStringList &list);
   // reaction to the signal "toggleOutline" from QmitkLabelSetTableWidget
   void OnToggleOutline(bool);
 
 private:
   enum TableColumns
   {
     NAME_COL = 0,
     LOCKED_COL,
     COLOR_COL,
     VISIBLE_COL
   };
 
   void WaitCursorOn();
 
   void WaitCursorOff();
 
   void RestoreOverrideCursor();
 
   void OnThreadedCalculationDone();
 
   void InitializeTableWidget();
 
   int GetPixelValueOfSelectedItem();
 
   mitk::LabelSetImage *GetWorkingImage();
 
   mitk::DataNode *GetWorkingNode();
 
   Ui::QmitkLabelSetWidgetControls m_Controls;
 
   mitk::ColorSequenceRainbow m_ColorSequenceRainbow;
 
   mitk::DataStorage *m_DataStorage;
 
   QCompleter *m_Completer;
 
   mitk::ToolManager *m_ToolManager;
 
   QStringList m_OrganColors;
 
   QStringList m_LabelStringList;
 
   bool m_ProcessingManualSelection;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidgetControls.ui b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidgetControls.ui
similarity index 100%
rename from Modules/SegmentationUI/Qmitk/QmitkLabelSetWidgetControls.ui
rename to Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidgetControls.ui
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkNewSegmentationDialog.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkNewSegmentationDialog.cpp
new file mode 100644
index 0000000000..02ed890382
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkNewSegmentationDialog.cpp
@@ -0,0 +1,317 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "QmitkNewSegmentationDialog.h"
+#include <ui_QmitkNewSegmentationDialog.h>
+
+#include <mitkAnatomicalStructureColorPresets.h>
+#include <mitkBaseApplication.h>
+#include <mitkLabelSetImage.h>
+
+#include <berryIPreferences.h>
+#include <berryIPreferencesService.h>
+#include <berryPlatform.h>
+
+#include <algorithm>
+#include <iterator>
+
+#include <vtkNew.h>
+
+#include <QColorDialog>
+#include <QCompleter>
+#include <QPushButton>
+#include <QStringListModel>
+
+#include <nlohmann/json.hpp>
+
+namespace
+{
+  // Get standard label name and color suggestions from embedded XML preset file for anatomical structures.
+  QmitkNewSegmentationDialog::SuggestionsType GetStandardSuggestions()
+  {
+    QmitkNewSegmentationDialog::SuggestionsType standardSuggestions;
+
+    vtkNew<mitk::AnatomicalStructureColorPresets> presets;
+    presets->LoadPreset();
+
+    for (const auto& preset : presets->GetColorPresets())
+    {
+      auto name = QString::fromStdString(preset.first);
+      auto color = QColor::fromRgbF(preset.second.GetRed(), preset.second.GetGreen(), preset.second.GetBlue());
+      standardSuggestions.emplace(name, color);
+    }
+
+    return standardSuggestions;
+  }
+
+  // Parse label name and color suggestions from a JSON file. An array of objects is expected, each consisting
+  // of a "name" string and an optional "color" string. If present, the "color" string must follow the conventions
+  // of QColor::setNamedColor(), i.e., #rrggbb or any SVG color keyword name like CornflowerBlue. Everything else
+  // in the JSON file is simply ignored. In case of any error, an empty map is returned.
+  QmitkNewSegmentationDialog::SuggestionsType ParseSuggestions(const std::string& filename)
+  {
+    std::ifstream file(filename);
+
+    if (!file.is_open())
+    {
+      MITK_ERROR << "Could not open \"" << filename << "\"!";
+      return {};
+    }
+
+    auto json = nlohmann::json::parse(file, nullptr, false);
+
+    if (json.is_discarded() || !json.is_array())
+    {
+      MITK_ERROR << "Could not parse \"" << filename << "\" as JSON array!";
+      return {};
+    }
+
+    QmitkNewSegmentationDialog::SuggestionsType parsedSuggestions;
+
+    for (const auto& obj : json)
+    {
+      if (!obj.is_object() || !obj.contains("name"))
+        continue;
+
+      auto name = QString::fromStdString(obj["name"]);
+
+      QColor color(QColor::Invalid);
+
+      if (obj.contains("color"))
+        color.setNamedColor(QString::fromStdString(obj["color"]));
+
+      parsedSuggestions.emplace(name, color);
+    }
+
+    if (parsedSuggestions.empty())
+      MITK_WARN << "Could not parse any suggestions from \"" << filename << "\"!";
+
+    return parsedSuggestions;
+  }
+
+  struct Preferences
+  {
+    QString labelSuggestions;
+    bool replaceStandardSuggestions;
+    bool suggestOnce;
+  };
+
+  // Get all relevant preferences and consider command-line arguments overrides.
+  Preferences GetPreferences()
+  {
+    auto nodePrefs = berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node("/org.mitk.views.segmentation");
+
+    Preferences prefs;
+    
+    prefs.labelSuggestions = QString::fromStdString(mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABEL_SUGGESTIONS.toStdString(), ""));
+
+    if (prefs.labelSuggestions.isEmpty())
+      prefs.labelSuggestions = nodePrefs->Get("label suggestions", "");
+
+    prefs.replaceStandardSuggestions = nodePrefs->GetBool("replace standard suggestions", true);
+    prefs.suggestOnce = nodePrefs->GetBool("suggest once", true);
+
+    return prefs;
+  }
+
+  // Get names of all labels in all layers of a LabelSetImage.
+  QStringList GetExistingLabelNames(mitk::LabelSetImage* labelSetImage)
+  {
+    QStringList existingLabelNames;
+    existingLabelNames.reserve(labelSetImage->GetTotalNumberOfLabels());
+
+    const auto numLayers = labelSetImage->GetNumberOfLayers();
+    for (std::remove_const_t<decltype(numLayers)> layerIndex = 0; layerIndex < numLayers; ++layerIndex)
+    {
+      const auto* labelSet = labelSetImage->GetLabelSet(layerIndex);
+
+      for (auto labelIter = labelSet->IteratorConstBegin(); labelIter != labelSet->IteratorConstEnd(); ++labelIter)
+      {
+        if (0 == labelIter->first)
+          continue; // Ignore background label
+
+        auto name = QString::fromStdString(labelIter->second->GetName());
+
+        if (!name.isEmpty()) // Potential duplicates do not matter for our purpose
+          existingLabelNames.push_back(name);
+      }
+    }
+
+    return existingLabelNames;
+  }
+
+  // Remove blacklisted suggestions.
+  QmitkNewSegmentationDialog::SuggestionsType FilterSuggestions(const QmitkNewSegmentationDialog::SuggestionsType& suggestions, const QStringList& blacklist)
+  {
+    QmitkNewSegmentationDialog::SuggestionsType filteredSuggestions;
+
+    std::remove_copy_if(suggestions.begin(), suggestions.end(), std::inserter(filteredSuggestions, filteredSuggestions.end()), [&blacklist](const auto& suggestion) {
+      return blacklist.contains(suggestion.first);
+    });
+
+    return filteredSuggestions;
+  }
+}
+
+QmitkNewSegmentationDialog::QmitkNewSegmentationDialog(QWidget *parent, mitk::LabelSetImage* labelSetImage, Mode mode)
+  : QDialog(parent),
+    m_Ui(new Ui::QmitkNewSegmentationDialog),
+    m_SuggestOnce(true),
+    m_Color(Qt::red)
+{
+  m_Ui->setupUi(this);
+
+  if (RenameLabel == mode)
+  {
+    this->setWindowTitle("Rename Label");
+    m_Ui->label->setText("New name and color of the label");
+    m_Ui->buttonBox->button(QDialogButtonBox::Ok)->setText("Rename label");
+  }
+  else
+  {
+    m_Ui->buttonBox->button(QDialogButtonBox::Ok)->setText("Create label");
+  }
+
+  auto* completer = new QCompleter(QStringList());
+  completer->setCaseSensitivity(Qt::CaseInsensitive);
+
+  m_Ui->nameLineEdit->setCompleter(completer);
+  m_Ui->nameLineEdit->setFocus();
+
+  connect(completer, qOverload<const QString&>(&QCompleter::activated), this, qOverload<const QString&>(&QmitkNewSegmentationDialog::OnSuggestionSelected));
+  connect(m_Ui->colorButton, &QToolButton::clicked, this, &QmitkNewSegmentationDialog::OnColorButtonClicked);
+  connect(m_Ui->buttonBox, &QDialogButtonBox::accepted, this, &QmitkNewSegmentationDialog::OnAccept);
+
+  this->UpdateColorButtonBackground();
+
+  auto prefs = GetPreferences();
+
+  if (!prefs.labelSuggestions.isEmpty())
+  {
+    auto suggestions = ParseSuggestions(prefs.labelSuggestions.toStdString());
+    this->SetSuggestions(suggestions, prefs.replaceStandardSuggestions && !suggestions.empty());
+  }
+  else
+  {
+    this->SetSuggestions(GetStandardSuggestions(), true);
+  }
+
+  if (nullptr != labelSetImage && prefs.suggestOnce)
+  {
+    auto existingLabelNames = GetExistingLabelNames(labelSetImage);
+    m_Suggestions = FilterSuggestions(m_Suggestions, existingLabelNames);
+
+    this->UpdateCompleterModel();
+  }
+}
+
+QmitkNewSegmentationDialog::~QmitkNewSegmentationDialog()
+{
+}
+
+void QmitkNewSegmentationDialog::UpdateColorButtonBackground()
+{
+  m_Ui->colorButton->setStyleSheet("background-color:" + m_Color.name());
+}
+
+QString QmitkNewSegmentationDialog::GetName() const
+{
+  return m_Name;
+}
+
+mitk::Color QmitkNewSegmentationDialog::GetColor() const
+{
+  mitk::Color color;
+
+  if (m_Color.isValid())
+  {
+    color.SetRed(m_Color.redF());
+    color.SetGreen(m_Color.greenF());
+    color.SetBlue(m_Color.blueF());
+  }
+  else
+  {
+    color.Set(1.0f, 0.0f, 0.0f);
+  }
+
+  return color;
+}
+
+void QmitkNewSegmentationDialog::SetName(const QString& name)
+{
+  m_Ui->nameLineEdit->setText(name);
+}
+
+void QmitkNewSegmentationDialog::SetColor(const mitk::Color& color)
+{
+  m_Color.setRgbF(color.GetRed(), color.GetGreen(), color.GetBlue());
+  this->UpdateColorButtonBackground();
+}
+
+void QmitkNewSegmentationDialog::SetSuggestions(const SuggestionsType& suggestions, bool replaceStandardSuggestions)
+{
+  if (replaceStandardSuggestions)
+  {
+    m_Suggestions = suggestions;
+  }
+  else
+  {
+    m_Suggestions = GetStandardSuggestions();
+
+    for (const auto& [name, color] : suggestions)
+    {
+      if (m_Suggestions.end() == m_Suggestions.find(name))
+        m_Suggestions[name] = color;
+    }
+  }
+
+  this->UpdateCompleterModel();
+}
+
+void QmitkNewSegmentationDialog::UpdateCompleterModel()
+{
+  QStringList names;
+
+  for (const auto& suggestion : m_Suggestions)
+    names << suggestion.first;
+
+  auto* completerModel = static_cast<QStringListModel*>(m_Ui->nameLineEdit->completer()->model());
+  completerModel->setStringList(names);
+}
+
+void QmitkNewSegmentationDialog::OnAccept()
+{
+  m_Name = m_Ui->nameLineEdit->text();
+  this->accept();
+}
+
+void QmitkNewSegmentationDialog::OnColorButtonClicked()
+{
+  auto color = QColorDialog::getColor(m_Color);
+
+  if (color.isValid())
+  {
+    m_Color = color;
+    this->UpdateColorButtonBackground();
+  }
+}
+
+void QmitkNewSegmentationDialog::OnSuggestionSelected(const QString &name)
+{
+  auto color = m_Suggestions[name];
+
+  if (color.isValid())
+  {
+    m_Color = color;
+    this->UpdateColorButtonBackground();
+  }
+}
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkNewSegmentationDialog.h b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkNewSegmentationDialog.h
new file mode 100644
index 0000000000..9f188540d1
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkNewSegmentationDialog.h
@@ -0,0 +1,80 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#ifndef QmitkNewSegmentationDialog_h
+#define QmitkNewSegmentationDialog_h
+
+#include <org_mitk_gui_qt_segmentation_Export.h>
+
+#include <mitkColorProperty.h>
+
+#include <map>
+
+#include <QColor>
+#include <QDialog>
+#include <QString>
+
+namespace mitk
+{
+  class LabelSetImage;
+}
+
+namespace Ui
+{
+  class QmitkNewSegmentationDialog;
+}
+
+/**
+  \brief Dialog for naming labels.
+*/
+class MITK_QT_SEGMENTATION QmitkNewSegmentationDialog : public QDialog
+{
+  Q_OBJECT
+
+public:
+  using SuggestionsType = std::map<QString, QColor>;
+
+  enum Mode
+  {
+    NewLabel,
+    RenameLabel
+  };
+
+  explicit QmitkNewSegmentationDialog(QWidget *parent = nullptr, mitk::LabelSetImage* labelSetImage = nullptr, Mode mode = NewLabel);
+  ~QmitkNewSegmentationDialog() override;
+
+  QString GetName() const;
+  mitk::Color GetColor() const;
+
+  void SetName(const QString& name);
+  void SetColor(const mitk::Color& color);
+
+private:
+  void OnAccept();
+  void OnSuggestionSelected(const QString& name);
+  void OnColorButtonClicked();
+
+  void SetSuggestions(const SuggestionsType& suggestions, bool replaceStandardSuggestions = false);
+  void UpdateColorButtonBackground();
+  void UpdateCompleterModel();
+
+  Ui::QmitkNewSegmentationDialog* m_Ui;
+
+  bool m_SuggestOnce;
+
+  QString m_Name;
+  QColor m_Color;
+
+  SuggestionsType m_Suggestions;
+};
+
+#endif
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkNewSegmentationDialog.ui b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkNewSegmentationDialog.ui
new file mode 100644
index 0000000000..ae71e75c55
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkNewSegmentationDialog.ui
@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QmitkNewSegmentationDialog</class>
+ <widget class="QDialog" name="QmitkNewSegmentationDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>250</width>
+    <height>105</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Create Label</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QGridLayout" name="gridLayout">
+     <item row="0" column="0" colspan="2">
+      <widget class="QLabel" name="label">
+       <property name="text">
+        <string>Name and color of the label</string>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="0">
+      <widget class="QToolButton" name="colorButton">
+       <property name="text">
+        <string/>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="1">
+      <widget class="QLineEdit" name="nameLineEdit"/>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>40</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>QmitkNewSegmentationDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>QmitkNewSegmentationDialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp
index f77ebd2f21..0ea32131f3 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp
@@ -1,135 +1,174 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkSegmentationPreferencePage.h"
 
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 #include <mitkBaseApplication.h>
 
 #include <QFileDialog>
 
 #include <ui_QmitkSegmentationPreferencePageControls.h>
 
 QmitkSegmentationPreferencePage::QmitkSegmentationPreferencePage()
   : m_Ui(new Ui::QmitkSegmentationPreferencePageControls),
     m_Control(nullptr),
     m_Initializing(false)
 {
 }
 
 QmitkSegmentationPreferencePage::~QmitkSegmentationPreferencePage()
 {
 }
 
 void QmitkSegmentationPreferencePage::Init(berry::IWorkbench::Pointer)
 {
 }
 
 void QmitkSegmentationPreferencePage::CreateQtControl(QWidget* parent)
 {
   m_Initializing = true;
   berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
 
   m_SegmentationPreferencesNode = prefService->GetSystemPreferences()->Node("/org.mitk.views.segmentation");
 
   m_Control = new QWidget(parent);
   m_Ui->setupUi(m_Control);
 
   connect(m_Ui->smoothingCheckBox, SIGNAL(stateChanged(int)), this, SLOT(OnSmoothingCheckboxChecked(int)));
   connect(m_Ui->labelSetPresetToolButton, SIGNAL(clicked()), this, SLOT(OnLabelSetPresetButtonClicked()));
+  connect(m_Ui->suggestionsToolButton, SIGNAL(clicked()), this, SLOT(OnSuggestionsButtonClicked()));
 
   this->Update();
   m_Initializing = false;
 }
 
 QWidget* QmitkSegmentationPreferencePage::GetQtControl() const
 {
   return m_Control;
 }
 
 bool QmitkSegmentationPreferencePage::PerformOk()
 {
   m_SegmentationPreferencesNode->PutBool("slim view", m_Ui->slimViewCheckBox->isChecked());
   m_SegmentationPreferencesNode->PutBool("draw outline", m_Ui->outlineRadioButton->isChecked());
   m_SegmentationPreferencesNode->PutBool("selection mode", m_Ui->selectionModeCheckBox->isChecked());
   m_SegmentationPreferencesNode->PutBool("smoothing hint", m_Ui->smoothingCheckBox->isChecked());
   m_SegmentationPreferencesNode->PutDouble("smoothing value", m_Ui->smoothingSpinBox->value());
   m_SegmentationPreferencesNode->PutDouble("decimation rate", m_Ui->decimationSpinBox->value());
   m_SegmentationPreferencesNode->PutDouble("closing ratio", m_Ui->closingSpinBox->value());
   m_SegmentationPreferencesNode->Put("label set preset", m_Ui->labelSetPresetLineEdit->text());
+  m_SegmentationPreferencesNode->PutBool("default label naming", m_Ui->defaultNameRadioButton->isChecked());
+  m_SegmentationPreferencesNode->Put("label suggestions", m_Ui->suggestionsLineEdit->text());
+  m_SegmentationPreferencesNode->PutBool("replace standard suggestions", m_Ui->replaceStandardSuggestionsCheckBox->isChecked());
+  m_SegmentationPreferencesNode->PutBool("suggest once", m_Ui->suggestOnceCheckBox->isChecked());
   return true;
 }
 
 void QmitkSegmentationPreferencePage::PerformCancel()
 {
 }
 
 void QmitkSegmentationPreferencePage::Update()
 {
   m_Ui->slimViewCheckBox->setChecked(m_SegmentationPreferencesNode->GetBool("slim view", false));
 
   if (m_SegmentationPreferencesNode->GetBool("draw outline", true))
   {
     m_Ui->outlineRadioButton->setChecked(true);
   }
   else
   {
     m_Ui->overlayRadioButton->setChecked(true);
   }
 
   m_Ui->selectionModeCheckBox->setChecked(m_SegmentationPreferencesNode->GetBool("selection mode", false));
 
   if (m_SegmentationPreferencesNode->GetBool("smoothing hint", true))
   {
     m_Ui->smoothingCheckBox->setChecked(true);
     m_Ui->smoothingSpinBox->setDisabled(true);
   }
   else
   {
     m_Ui->smoothingCheckBox->setChecked(false);
     m_Ui->smoothingSpinBox->setEnabled(true);
   }
 
   m_Ui->smoothingSpinBox->setValue(m_SegmentationPreferencesNode->GetDouble("smoothing value", 1.0));
   m_Ui->decimationSpinBox->setValue(m_SegmentationPreferencesNode->GetDouble("decimation rate", 0.5));
   m_Ui->closingSpinBox->setValue(m_SegmentationPreferencesNode->GetDouble("closing ratio", 0.0));
 
   auto labelSetPreset = mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABELSET_PRESET.toStdString(), "");
-  bool isOverridenByCmdLineArg = !labelSetPreset.empty();
+  bool isOverriddenByCmdLineArg = !labelSetPreset.empty();
 
-  if (!isOverridenByCmdLineArg)
+  if (!isOverriddenByCmdLineArg)
     labelSetPreset = m_SegmentationPreferencesNode->Get("label set preset", "").toStdString();
 
-  m_Ui->labelSetPresetLineEdit->setDisabled(isOverridenByCmdLineArg);
-  m_Ui->labelSetPresetToolButton->setDisabled(isOverridenByCmdLineArg);
-  m_Ui->labelSetPresetCmdLineArgLabel->setVisible(isOverridenByCmdLineArg);
+  m_Ui->labelSetPresetLineEdit->setDisabled(isOverriddenByCmdLineArg);
+  m_Ui->labelSetPresetToolButton->setDisabled(isOverriddenByCmdLineArg);
+  m_Ui->labelSetPresetCmdLineArgLabel->setVisible(isOverriddenByCmdLineArg);
 
   m_Ui->labelSetPresetLineEdit->setText(QString::fromStdString(labelSetPreset));
+
+  if (m_SegmentationPreferencesNode->GetBool("default label naming", true))
+  {
+    m_Ui->defaultNameRadioButton->setChecked(true);
+  }
+  else
+  {
+    m_Ui->askForNameRadioButton->setChecked(true);
+  }
+
+  auto labelSuggestions = mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABEL_SUGGESTIONS.toStdString(), "");
+  isOverriddenByCmdLineArg = !labelSuggestions.empty();
+
+  if (!isOverriddenByCmdLineArg)
+    labelSuggestions = m_SegmentationPreferencesNode->Get("label suggestions", "").toStdString();
+
+  m_Ui->defaultNameRadioButton->setDisabled(isOverriddenByCmdLineArg);
+  m_Ui->askForNameRadioButton->setDisabled(isOverriddenByCmdLineArg);
+  m_Ui->suggestionsLineEdit->setDisabled(isOverriddenByCmdLineArg);
+  m_Ui->suggestionsToolButton->setDisabled(isOverriddenByCmdLineArg);
+  m_Ui->suggestionsCmdLineArgLabel->setVisible(isOverriddenByCmdLineArg);
+
+  m_Ui->suggestionsLineEdit->setText(QString::fromStdString(labelSuggestions));
+
+  m_Ui->replaceStandardSuggestionsCheckBox->setChecked(m_SegmentationPreferencesNode->GetBool("replace standard suggestions", true));
+  m_Ui->suggestOnceCheckBox->setChecked(m_SegmentationPreferencesNode->GetBool("suggest once", true));
 }
 
 void QmitkSegmentationPreferencePage::OnSmoothingCheckboxChecked(int state)
 {
   if (state != Qt::Unchecked)
     m_Ui->smoothingSpinBox->setDisabled(true);
   else
     m_Ui->smoothingSpinBox->setEnabled(true);
 }
 
 void QmitkSegmentationPreferencePage::OnLabelSetPresetButtonClicked()
 {
   const auto filename = QFileDialog::getOpenFileName(m_Control, QStringLiteral("Load Label Set Preset"), QString(), QStringLiteral("Label set preset (*.lsetp)"));
 
   if (!filename.isEmpty())
     m_Ui->labelSetPresetLineEdit->setText(filename);
 }
+
+void QmitkSegmentationPreferencePage::OnSuggestionsButtonClicked()
+{
+  const auto filename = QFileDialog::getOpenFileName(m_Control, QStringLiteral("Load Label Suggestions"), QString(), QStringLiteral("Label suggestions (*.json)"));
+
+  if (!filename.isEmpty())
+    m_Ui->suggestionsLineEdit->setText(filename);
+}
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.h b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.h
index fc6406faa2..8c04073a86 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.h
@@ -1,65 +1,66 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKSEGMENTATIONPREFERENCEPAGE_H
 #define QMITKSEGMENTATIONPREFERENCEPAGE_H
 
 #include "org_mitk_gui_qt_segmentation_Export.h"
 
 #include <berryIPreferences.h>
 #include <berryIQtPreferencePage.h>
 
 class QWidget;
 
 namespace Ui
 {
   class QmitkSegmentationPreferencePageControls;
 }
 
 class MITK_QT_SEGMENTATION QmitkSegmentationPreferencePage : public QObject, public berry::IQtPreferencePage
 {
   Q_OBJECT
   Q_INTERFACES(berry::IPreferencePage)
 
 public:
 
   QmitkSegmentationPreferencePage();
   ~QmitkSegmentationPreferencePage() override;
 
   void Init(berry::IWorkbench::Pointer workbench) override;
 
   void CreateQtControl(QWidget* widget) override;
 
   QWidget* GetQtControl() const override;
 
   bool PerformOk() override;
 
   void PerformCancel() override;
 
   void Update() override;
 
 protected Q_SLOTS:
 
   void OnSmoothingCheckboxChecked(int);
   void OnLabelSetPresetButtonClicked();
+  void OnSuggestionsButtonClicked();
 
 protected:
 
   Ui::QmitkSegmentationPreferencePageControls* m_Ui;
   QWidget* m_Control;
 
   bool m_Initializing;
 
   berry::IPreferences::Pointer m_SegmentationPreferencesNode;
 };
 
 #endif // QMITKSEGMENTATIONPREFERENCEPAGE_H
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePageControls.ui b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePageControls.ui
index 7728e50e20..ee4674f966 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePageControls.ui
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePageControls.ui
@@ -1,205 +1,323 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkSegmentationPreferencePageControls</class>
  <widget class="QWidget" name="QmitkSegmentationPreferencePageControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>640</width>
-    <height>480</height>
+    <width>656</width>
+    <height>779</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QFormLayout" name="formLayout">
    <item row="0" column="0">
     <widget class="QLabel" name="slimViewLabel">
      <property name="text">
       <string>Slim view</string>
      </property>
     </widget>
    </item>
    <item row="0" column="1">
     <widget class="QCheckBox" name="slimViewCheckBox">
      <property name="text">
       <string>Hide tool button texts and increase icon size</string>
      </property>
     </widget>
    </item>
    <item row="1" column="0">
     <widget class="QLabel" name="displayLabel">
      <property name="text">
       <string>2D display</string>
      </property>
     </widget>
    </item>
    <item row="1" column="1">
     <layout class="QVBoxLayout" name="displayOptionsLayout">
      <item>
       <widget class="QRadioButton" name="outlineRadioButton">
        <property name="text">
         <string>Draw as outline</string>
        </property>
+       <property name="checked">
+        <bool>true</bool>
+       </property>
+       <attribute name="buttonGroup">
+        <string notr="true">displayButtonGroup</string>
+       </attribute>
       </widget>
      </item>
      <item>
       <widget class="QRadioButton" name="overlayRadioButton">
        <property name="text">
         <string>Draw as transparent overlay</string>
        </property>
+       <attribute name="buttonGroup">
+        <string notr="true">displayButtonGroup</string>
+       </attribute>
       </widget>
      </item>
     </layout>
    </item>
    <item row="2" column="0">
     <widget class="QLabel" name="selectionModeLabel">
      <property name="text">
       <string>Data node selection mode</string>
      </property>
     </widget>
    </item>
    <item row="2" column="1">
     <widget class="QCheckBox" name="selectionModeCheckBox">
      <property name="toolTip">
       <string>If checked the segmentation plugin ensures that only the selected segmentation and the reference image are visible at one time.</string>
      </property>
      <property name="text">
       <string>Show only selected nodes</string>
      </property>
     </widget>
    </item>
    <item row="3" column="0">
     <widget class="QLabel" name="surfaceCreationLabel">
      <property name="text">
       <string>Smoothed surface creation</string>
      </property>
     </widget>
    </item>
    <item row="3" column="1">
     <layout class="QFormLayout" name="surfaceLayout">
      <property name="horizontalSpacing">
       <number>8</number>
      </property>
      <property name="verticalSpacing">
       <number>8</number>
      </property>
      <item row="1" column="0">
       <widget class="QLabel" name="smoothingLabel">
        <property name="text">
         <string>Smoothing value (mm)</string>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="QDoubleSpinBox" name="smoothingSpinBox">
        <property name="toolTip">
         <string>The Smoothing value is used as variance for a gaussian blur.</string>
        </property>
        <property name="singleStep">
         <double>0.500000000000000</double>
        </property>
        <property name="value">
         <double>1.000000000000000</double>
        </property>
       </widget>
      </item>
      <item row="2" column="0">
       <widget class="QLabel" name="decimationLabel">
        <property name="text">
         <string>Decimation rate</string>
        </property>
       </widget>
      </item>
      <item row="2" column="1">
       <widget class="QDoubleSpinBox" name="decimationSpinBox">
        <property name="toolTip">
         <string>Valid range is [0, 1). High values increase decimation, especially when very close to 1. A value of 0 disables decimation.</string>
        </property>
        <property name="maximum">
         <double>0.990000000000000</double>
        </property>
        <property name="singleStep">
         <double>0.100000000000000</double>
        </property>
        <property name="value">
         <double>0.500000000000000</double>
        </property>
       </widget>
      </item>
      <item row="3" column="0">
       <widget class="QLabel" name="closingLabel">
        <property name="text">
         <string>Closing Ratio</string>
        </property>
       </widget>
      </item>
      <item row="3" column="1">
       <widget class="QDoubleSpinBox" name="closingSpinBox">
        <property name="toolTip">
         <string>Valid range is [0, 1]. Higher values increase closing. A value of 0 disables closing.</string>
        </property>
        <property name="maximum">
         <double>1.000000000000000</double>
        </property>
        <property name="singleStep">
         <double>0.100000000000000</double>
        </property>
       </widget>
      </item>
      <item row="0" column="0" colspan="2">
       <widget class="QCheckBox" name="smoothingCheckBox">
        <property name="toolTip">
         <string>If checked the segmentation plugin ensures that only the selected segmentation and the reference image are visible at one time.</string>
        </property>
        <property name="text">
         <string>Use image spacing as smoothing value hint</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item row="4" column="0">
     <widget class="QLabel" name="labelSetPresetLabel">
      <property name="text">
       <string>Default label set preset</string>
      </property>
     </widget>
    </item>
    <item row="4" column="1">
     <layout class="QGridLayout" name="gridLayout">
      <item row="0" column="0">
       <widget class="QLineEdit" name="labelSetPresetLineEdit">
        <property name="clearButtonEnabled">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QToolButton" name="labelSetPresetToolButton">
        <property name="text">
         <string>...</string>
        </property>
       </widget>
      </item>
      <item row="1" column="0" colspan="2">
       <widget class="QLabel" name="labelSetPresetCmdLineArgLabel">
        <property name="text">
         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;The default label set preset is currently overriden by the &lt;/span&gt;&lt;span style=&quot; font-family:'Courier New'; color:#ff0000;&quot;&gt;Segmentation.labelSetPreset&lt;/span&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt; command-line argument.&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
        </property>
        <property name="textFormat">
         <enum>Qt::RichText</enum>
        </property>
        <property name="wordWrap">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
+   <item row="5" column="0">
+    <widget class="QLabel" name="labelCreationLabel">
+     <property name="text">
+      <string>Label creation</string>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="1">
+    <layout class="QVBoxLayout" name="verticalLayout">
+     <item>
+      <widget class="QRadioButton" name="defaultNameRadioButton">
+       <property name="text">
+        <string>Assign default name and color</string>
+       </property>
+       <property name="checked">
+        <bool>true</bool>
+       </property>
+       <attribute name="buttonGroup">
+        <string notr="true">labelCreationButtonGroup</string>
+       </attribute>
+      </widget>
+     </item>
+     <item>
+      <widget class="QRadioButton" name="askForNameRadioButton">
+       <property name="text">
+        <string>Ask for name and color</string>
+       </property>
+       <attribute name="buttonGroup">
+        <string notr="true">labelCreationButtonGroup</string>
+       </attribute>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="6" column="0">
+    <widget class="QLabel" name="labelSuggestions">
+     <property name="text">
+      <string>Label suggestions</string>
+     </property>
+    </widget>
+   </item>
+   <item row="6" column="1">
+    <layout class="QGridLayout" name="gridLayout_2">
+     <item row="0" column="0">
+      <widget class="QLineEdit" name="suggestionsLineEdit">
+       <property name="clearButtonEnabled">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="1">
+      <widget class="QToolButton" name="suggestionsToolButton">
+       <property name="text">
+        <string>...</string>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="0" colspan="2">
+      <widget class="QLabel" name="suggestionsCmdLineArgLabel">
+       <property name="text">
+        <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;Suggestions are currently enforced by the &lt;/span&gt;&lt;span style=&quot; font-family:'Courier New'; color:#ff0000;&quot;&gt;Segmentation.labelSuggestions&lt;/span&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt; command-line argument.&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+       </property>
+       <property name="textFormat">
+        <enum>Qt::RichText</enum>
+       </property>
+       <property name="wordWrap">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="7" column="1">
+    <widget class="QCheckBox" name="replaceStandardSuggestionsCheckBox">
+     <property name="text">
+      <string>Replace standard organ suggestions</string>
+     </property>
+     <property name="checked">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="8" column="1">
+    <widget class="QCheckBox" name="suggestOnceCheckBox">
+     <property name="text">
+      <string>Suggest once per segmentation</string>
+     </property>
+     <property name="checked">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="9" column="1">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>40</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
+ <buttongroups>
+  <buttongroup name="displayButtonGroup"/>
+  <buttongroup name="labelCreationButtonGroup"/>
+ </buttongroups>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/Common/QmitkLabelsWidget.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/Common/QmitkLabelsWidget.cpp
index 3345f642f1..9e354d92ae 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/Common/QmitkLabelsWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/Common/QmitkLabelsWidget.cpp
@@ -1,173 +1,196 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkLabelsWidget.h"
 #include <ui_QmitkLabelsWidgetControls.h>
 
 // mitk
 #include <mitkDataNode.h>
 #include <mitkImage.h>
 #include <mitkLabelSetImage.h>
 #include <mitkLabelSetImageHelper.h>
 #include <mitkToolManagerProvider.h>
 
 // Qmitk
 #include <QmitkAbstractNodeSelectionWidget.h>
 #include <QmitkStyleManager.h>
+#include <QmitkNewSegmentationDialog.h>
 
 #include "../QmitkSaveMultiLabelPresetAction.h"
 #include "../QmitkLoadMultiLabelPresetAction.h"
 
 // Qt
 #include <QMessageBox>
 
 QmitkLabelsWidget::QmitkLabelsWidget(QWidget *parent)
   : QWidget(parent)
   , m_Controls(new Ui::QmitkLabelsWidgetControls)
   , m_ToolManager(nullptr)
+  , m_DefaultLabelNaming(true)
 {
   m_Controls->setupUi(this);
 
   m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
 
   m_Controls->savePresetButton->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-save.svg")));
   m_Controls->loadPresetButton->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-open.svg")));
 
   connect(m_Controls->newLabelButton, &QToolButton::clicked, this, &QmitkLabelsWidget::OnNewLabel);
   connect(m_Controls->lockExteriorButton, &QToolButton::toggled, this, &QmitkLabelsWidget::OnLockExterior);
   connect(m_Controls->savePresetButton, &QToolButton::clicked, this, &QmitkLabelsWidget::OnSavePreset);
   connect(m_Controls->loadPresetButton, &QToolButton::clicked, this, &QmitkLabelsWidget::OnLoadPreset);
   connect(m_Controls->showLabelTableButton, &QToolButton::toggled, this, &QmitkLabelsWidget::ShowLabelTable);
 
   this->UpdateGUI();
 }
 
 QmitkLabelsWidget::~QmitkLabelsWidget()
 {
   delete m_Controls;
 }
 
 void QmitkLabelsWidget::UpdateGUI()
 {
   m_Controls->newLabelButton->setEnabled(false);
   m_Controls->lockExteriorButton->setEnabled(false);
   m_Controls->lockExteriorButton->setChecked(false);
   m_Controls->savePresetButton->setEnabled(false);
   m_Controls->loadPresetButton->setEnabled(false);
   m_Controls->showLabelTableButton->setEnabled(false);
   m_Controls->showLabelTableButton->setChecked(false);
 
   mitk::LabelSetImage* workingImage = this->GetWorkingImage();
   if (nullptr == workingImage)
   {
     return;
   }
 
   int activeLayer = workingImage->GetActiveLayer();
   m_Controls->lockExteriorButton->setEnabled(true);
   m_Controls->lockExteriorButton->setChecked(workingImage->GetLabel(0, activeLayer)->GetLocked());
   m_Controls->showLabelTableButton->setEnabled(true);
   m_Controls->showLabelTableButton->setChecked(true);
   m_Controls->newLabelButton->setEnabled(true);
   m_Controls->savePresetButton->setEnabled(true);
   m_Controls->loadPresetButton->setEnabled(true);
 }
 
+void QmitkLabelsWidget::SetDefaultLabelNaming(bool defaultLabelNaming)
+{
+  m_DefaultLabelNaming = defaultLabelNaming;
+}
+
 mitk::LabelSetImage* QmitkLabelsWidget::GetWorkingImage()
 {
   mitk::DataNode* workingNode = this->GetWorkingNode();
   if (nullptr == workingNode)
   {
     return nullptr;
   }
 
   auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   return workingImage;
 }
 
 mitk::DataNode* QmitkLabelsWidget::GetWorkingNode()
 {
   mitk::DataNode* referenceNode = m_ToolManager->GetWorkingData(0);
   return referenceNode;
 }
 
 void QmitkLabelsWidget::OnNewLabel()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode* workingNode = this->GetWorkingNode();
   if (nullptr == workingNode)
   {
     return;
   }
 
   auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   if (nullptr == workingImage)
   {
     return;
   }
 
-  this->WaitCursorOn();
   mitk::Label::Pointer newLabel = mitk::LabelSetImageHelper::CreateNewLabel(workingImage);
+
+  if (!m_DefaultLabelNaming)
+  {
+    QmitkNewSegmentationDialog dialog(this, workingImage);
+    dialog.SetName(QString::fromStdString(newLabel->GetName()));
+    dialog.SetColor(newLabel->GetColor());
+
+    if (QDialog::Rejected == dialog.exec())
+      return;
+
+    auto name = dialog.GetName();
+
+    if (!name.isEmpty())
+      newLabel->SetName(name.toStdString());
+
+    newLabel->SetColor(dialog.GetColor());
+  }
+
   workingImage->GetActiveLabelSet()->AddLabel(newLabel);
-  this->WaitCursorOff();
 
   this->UpdateGUI();
   emit LabelsChanged();
 }
 
 void QmitkLabelsWidget::OnLockExterior(bool checked)
 {
   auto workingImage = this->GetWorkingImage();
   if (nullptr == workingImage)
   {
     return;
   }
 
   workingImage->GetLabel(0)->SetLocked(checked);
 }
 
 void QmitkLabelsWidget::OnSavePreset()
 {
   auto workingNode = this->GetWorkingNode();
   QmitkAbstractNodeSelectionWidget::NodeList nodes;
   nodes.append(workingNode);
 
   QmitkSaveMultiLabelPresetAction action;
   action.Run(nodes);
 }
 
 void QmitkLabelsWidget::OnLoadPreset()
 {
   auto workingNode = this->GetWorkingNode();
   QmitkAbstractNodeSelectionWidget::NodeList nodes;
   nodes.append(workingNode);
 
   QmitkLoadMultiLabelPresetAction action;
   action.Run(nodes);
 }
 
 void QmitkLabelsWidget::WaitCursorOn()
 {
   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 }
 
 void QmitkLabelsWidget::WaitCursorOff()
 {
   this->RestoreOverrideCursor();
 }
 
 void QmitkLabelsWidget::RestoreOverrideCursor()
 {
   QApplication::restoreOverrideCursor();
 }
 
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/Common/QmitkLabelsWidget.h b/Plugins/org.mitk.gui.qt.segmentation/src/internal/Common/QmitkLabelsWidget.h
index bd74ae2ead..127775d686 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/Common/QmitkLabelsWidget.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/Common/QmitkLabelsWidget.h
@@ -1,82 +1,86 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKLABELSWIDGET_H
 #define QMITKLABELSWIDGET_H
 
 // mitk core
 #include <mitkWeakPointer.h>
 
 // Qt
 #include <QWidget>
 
 namespace Ui
 {
   class QmitkLabelsWidgetControls;
 }
 
 namespace mitk
 {
   class DataNode;
   class Image;
   class LabelSetImage;
   class ToolManager;
 }
 
 class QmitkLabelsWidget : public QWidget
 {
   Q_OBJECT
 
 public:
 
   explicit QmitkLabelsWidget(QWidget* parent = nullptr);
   ~QmitkLabelsWidget() override;
 
   void UpdateGUI();
 
+  void SetDefaultLabelNaming(bool defaultLabelNaming);
+
 Q_SIGNALS:
 
   void LabelsChanged();
 
   void ShowLabelTable(bool);
 
 private:
 
   mitk::LabelSetImage* GetWorkingImage();
 
   mitk::DataNode* GetWorkingNode();
 
   // reaction to button "New Label"
   void OnNewLabel();
 
   // reaction to the button "Lock exterior"
   void OnLockExterior(bool);
 
   // reaction to button "Save Preset"
   void OnSavePreset();
 
   // reaction to button "Load Preset"
   void OnLoadPreset();
 
   void WaitCursorOn();
 
   void WaitCursorOff();
 
   void RestoreOverrideCursor();
 
   Ui::QmitkLabelsWidgetControls* m_Controls;
 
   mitk::ToolManager* m_ToolManager;
 
+  bool m_DefaultLabelNaming;
+
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index b6dd33bffe..98faec74c8 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,995 +1,989 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkSegmentationView.h"
 #include "mitkPluginActivator.h"
 
 // blueberry
 #include <berryIWorkbenchPage.h>
 
 // mitk
 #include <mitkApplicationCursor.h>
 #include <mitkBaseApplication.h>
 #include <mitkCameraController.h>
-#include <mitkImageTimeSelector.h>
 #include <mitkLabelSetImage.h>
 #include <mitkLabelSetImageHelper.h>
 #include <mitkLabelSetIOHelper.h>
 #include <mitkNodePredicateSubGeometry.h>
 #include <mitkSegmentationObjectFactory.h>
 #include <mitkSegTool2D.h>
 #include <mitkStatusBar.h>
 #include <mitkToolManagerProvider.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 #include <mitkWorkbenchUtil.h>
 
 // Qmitk
 #include <QmitkRenderWindow.h>
-#include <QmitkSegmentationOrganNamesHandling.cpp>
+#include <QmitkStaticDynamicSegmentationDialog.h>
+#include <QmitkNewSegmentationDialog.h>
 
 // us
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
 // Qt
 #include <QMessageBox>
 #include <QShortcut>
 #include <QDir>
 
 #include <regex>
 
 const std::string QmitkSegmentationView::VIEW_ID = "org.mitk.views.segmentation";
 
 QmitkSegmentationView::QmitkSegmentationView()
   : m_Parent(nullptr)
   , m_Controls(nullptr)
   , m_RenderWindowPart(nullptr)
   , m_ToolManager(nullptr)
   , m_ReferenceNode(nullptr)
   , m_WorkingNode(nullptr)
   , m_DrawOutline(true)
   , m_SelectionMode(false)
   , m_MouseCursorSet(false)
+  , m_DefaultLabelNaming(true)
 {
   auto isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   auto isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
   auto isDti = mitk::NodePredicateDataType::New("TensorImage");
   auto isOdf = mitk::NodePredicateDataType::New("OdfImage");
   auto isSegment = mitk::NodePredicateDataType::New("Segment");
 
   auto validImages = mitk::NodePredicateOr::New();
   validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegment)));
   validImages->AddPredicate(isDwi);
   validImages->AddPredicate(isDti);
   validImages->AddPredicate(isOdf);
 
   auto isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   auto isMask = mitk::NodePredicateAnd::New(isBinary, isImage);
 
   auto validSegmentations = mitk::NodePredicateOr::New();
   validSegmentations->AddPredicate(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   validSegmentations->AddPredicate(isMask);
 
   m_SegmentationPredicate = mitk::NodePredicateAnd::New();
   m_SegmentationPredicate->AddPredicate(validSegmentations);
   m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
 
   m_ReferencePredicate = mitk::NodePredicateAnd::New();
   m_ReferencePredicate->AddPredicate(validImages);
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(m_SegmentationPredicate));
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
 }
 
 QmitkSegmentationView::~QmitkSegmentationView()
 {
   if (nullptr != m_Controls)
   {
     OnLooseLabelSetConnection();
 
     // deactivate all tools
     m_ToolManager->ActivateTool(-1);
 
     // removing all observers
     for (NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter)
     {
       (*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
     }
     m_WorkingDataObserverTags.clear();
 
     mitk::RenderingManager::GetInstance()->RemoveObserver(m_RenderingManagerObserverTag);
 
     ctkPluginContext* context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
     service->RemoveAllPlanePositions();
     context->ungetService(ppmRef);
 
     m_ToolManager->SetReferenceData(nullptr);
     m_ToolManager->SetWorkingData(nullptr);
   }
 
   delete m_Controls;
 }
 
 /**********************************************************************/
 /* private Q_SLOTS                                                    */
 /**********************************************************************/
 void QmitkSegmentationView::OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   m_ToolManager->ActivateTool(-1);
 
   if (nodes.empty())
   {
     m_Controls->workingNodeSelector->SetNodePredicate(m_SegmentationPredicate);
     m_ReferenceNode = nullptr;
     m_ToolManager->SetReferenceData(m_ReferenceNode);
     this->UpdateGUI();
     return;
   }
 
   m_ReferenceNode = nodes.first();
   m_ToolManager->SetReferenceData(m_ReferenceNode);
   if (m_ReferenceNode.IsNotNull())
   {
     // set a predicate such that a segmentation fits the selected reference image geometry
     auto segPredicate = mitk::NodePredicateAnd::New(m_SegmentationPredicate.GetPointer(),
       mitk::NodePredicateSubGeometry::New(m_ReferenceNode->GetData()->GetGeometry()));
 
     m_Controls->workingNodeSelector->SetNodePredicate(segPredicate);
 
     if (m_SelectionMode)
     {
       // hide all image nodes to later show only the automatically selected ones
       mitk::DataStorage::SetOfObjects::ConstPointer imageNodes =
         this->GetDataStorage()->GetSubset(m_ReferencePredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = imageNodes->begin(); iter != imageNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
     }
     m_ReferenceNode->SetVisibility(true);
   }
 
   this->UpdateGUI();
 }
 
 void QmitkSegmentationView::OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   m_ToolManager->ActivateTool(-1);
 
   // Remove observer if one was registered
   auto finding = m_WorkingDataObserverTags.find(m_WorkingNode);
   if (finding != m_WorkingDataObserverTags.end())
   {
     m_WorkingNode->GetProperty("visible")->RemoveObserver(m_WorkingDataObserverTags[m_WorkingNode]);
     m_WorkingDataObserverTags.erase(m_WorkingNode);
   }
 
   if (nodes.empty())
   {
     m_WorkingNode = nullptr;
     m_ToolManager->SetWorkingData(m_WorkingNode);
     this->UpdateGUI();
     return;
   }
 
   if (m_ReferenceNode.IsNull())
   {
     this->UpdateGUI();
     return;
   }
 
   mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image*>(m_ReferenceNode->GetData());
   if (referenceImage.IsNull())
   {
     this->UpdateGUI();
     return;
   }
 
   m_WorkingNode = nodes.first();
   m_ToolManager->SetWorkingData(m_WorkingNode);
   if (m_WorkingNode.IsNotNull())
   {
     if (m_SelectionMode)
     {
       // hide all segmentation nodes to later show only the selected ones
       mitk::DataStorage::SetOfObjects::ConstPointer segmentationNodes =
         this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = segmentationNodes->begin(); iter != segmentationNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
     }
     m_WorkingNode->SetVisibility(true);
 
     this->OnEstablishLabelSetConnection();
     m_Controls->labelSetWidget->ResetAllTableWidgetItems();
 
     auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
     command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
     m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(m_WorkingNode,
       m_WorkingNode->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
 
     this->InitializeRenderWindows(referenceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, false);
   }
 
   this->UpdateGUI();
 }
 
 void QmitkSegmentationView::OnVisibilityShortcutActivated()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
 
   bool isVisible = false;
   m_WorkingNode->GetBoolProperty("visible", isVisible);
   m_WorkingNode->SetVisibility(!isVisible);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::OnLabelToggleShortcutActivated()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
 
   auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
   if (nullptr == workingImage)
   {
     return;
   }
 
   this->WaitCursorOn();
   workingImage->GetActiveLabelSet()->SetNextActiveLabel();
   workingImage->Modified();
   this->WaitCursorOff();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::OnNewSegmentation()
 {
   m_ToolManager->ActivateTool(-1);
 
   if (m_ReferenceNode.IsNull())
   {
     MITK_ERROR << "'Create new segmentation' button should never be clickable unless a reference image is selected.";
     return;
   }
 
   mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image*>(m_ReferenceNode->GetData());
   if (referenceImage.IsNull())
   {
     QMessageBox::information(
       m_Parent, "New segmentation", "Please load and select an image before starting some action.");
     return;
   }
 
   if (referenceImage->GetDimension() <= 1)
   {
     QMessageBox::information(
       m_Parent, "New segmentation", "Segmentation is currently not supported for 2D images");
     return;
   }
 
-  const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
-  unsigned int imageTimeStep = 0;
-  if (referenceImage->GetTimeGeometry()->IsValidTimePoint(currentTimePoint))
-  {
-    imageTimeStep = referenceImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
-  }
-
   auto segTemplateImage = referenceImage;
   if (referenceImage->GetDimension() > 3)
   {
-    auto result = QMessageBox::question(m_Parent,
-      tr("Create a static or dynamic segmentation?"),
-      tr("The selected image has multiple time steps.\n\nDo you want to create a static "
-        "segmentation that is identical for all time steps or do you want to create a "
-        "dynamic segmentation to segment individual time steps?"),
-      tr("Create static segmentation"), tr("Create dynamic segmentation"),
-      QString(), 0, 0);
-    if (result == 0)
-    {
-      auto selector = mitk::ImageTimeSelector::New();
-      selector->SetInput(referenceImage);
-      selector->SetTimeNr(0);
-      selector->Update();
-
-      const auto refTimeGeometry = referenceImage->GetTimeGeometry();
-      auto newTimeGeometry = mitk::ProportionalTimeGeometry::New();
-      newTimeGeometry->SetFirstTimePoint(refTimeGeometry->GetMinimumTimePoint());
-      newTimeGeometry->SetStepDuration(refTimeGeometry->GetMaximumTimePoint() - refTimeGeometry->GetMinimumTimePoint());
-
-      mitk::Image::Pointer newImage = selector->GetOutput();
-      newTimeGeometry->SetTimeStepGeometry(referenceImage->GetGeometry(imageTimeStep), 0);
-      newImage->SetTimeGeometry(newTimeGeometry);
-      segTemplateImage = newImage;
-    }
+    QmitkStaticDynamicSegmentationDialog dialog(m_Parent);
+    dialog.SetReferenceImage(referenceImage.GetPointer());
+    dialog.exec();
+    segTemplateImage = dialog.GetSegmentationTemplate();
   }
 
   mitk::DataNode::Pointer newSegmentationNode;
   try
   {
     this->WaitCursorOn();
     newSegmentationNode = mitk::LabelSetImageHelper::CreateNewSegmentationNode(m_ReferenceNode, segTemplateImage);
     this->WaitCursorOff();
   }
   catch (mitk::Exception& e)
   {
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::warning(m_Parent, "New segmentation", "Could not create a new segmentation.");
     return;
   }
 
   auto newLabelSetImage = dynamic_cast<mitk::LabelSetImage*>(newSegmentationNode->GetData());
   if (nullptr == newLabelSetImage)
   {
     // something went wrong
     return;
   }
 
   const auto labelSetPreset = this->GetDefaultLabelSetPreset();
 
   if (labelSetPreset.empty() || !mitk::LabelSetIOHelper::LoadLabelSetImagePreset(labelSetPreset, newLabelSetImage))
   {
-    mitk::Label::Pointer newLabel = mitk::LabelSetImageHelper::CreateNewLabel(newLabelSetImage);
+    auto newLabel = mitk::LabelSetImageHelper::CreateNewLabel(newLabelSetImage);
+
+    if (!m_DefaultLabelNaming)
+    {
+      QmitkNewSegmentationDialog dialog(m_Parent);
+      dialog.SetName(QString::fromStdString(newLabel->GetName()));
+      dialog.SetColor(newLabel->GetColor());
+
+      if (QDialog::Rejected == dialog.exec())
+        return;
+
+      auto name = dialog.GetName();
+
+      if (!name.isEmpty())
+        newLabel->SetName(name.toStdString());
+
+      newLabel->SetColor(dialog.GetColor());
+    }
+
     newLabelSetImage->GetActiveLabelSet()->AddLabel(newLabel);
   }
 
   if (!this->GetDataStorage()->Exists(newSegmentationNode))
   {
     this->GetDataStorage()->Add(newSegmentationNode, m_ReferenceNode);
   }
 
   if (m_ToolManager->GetWorkingData(0))
   {
     m_ToolManager->GetWorkingData(0)->SetSelected(false);
   }
 
   newSegmentationNode->SetSelected(true);
   m_Controls->workingNodeSelector->SetCurrentSelectedNode(newSegmentationNode);
 }
 
 std::string QmitkSegmentationView::GetDefaultLabelSetPreset() const
 {
   auto labelSetPreset = mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABELSET_PRESET.toStdString(), "");
 
   if (labelSetPreset.empty())
     labelSetPreset = m_LabelSetPresetPreference.toStdString();
 
   return labelSetPreset;
 }
 
 void QmitkSegmentationView::OnManualTool2DSelected(int id)
 {
   this->ResetMouseCursor();
   mitk::StatusBar::GetInstance()->DisplayText("");
 
   if (id >= 0)
   {
     std::string text = "Active Tool: \"";
     text += m_ToolManager->GetToolById(id)->GetName();
     text += "\"";
     mitk::StatusBar::GetInstance()->DisplayText(text.c_str());
 
     us::ModuleResource resource = m_ToolManager->GetToolById(id)->GetCursorIconResource();
     this->SetMouseCursor(resource, 0, 0);
   }
 }
 
 void QmitkSegmentationView::OnShowMarkerNodes(bool state)
 {
   mitk::SegTool2D::Pointer manualSegmentationTool;
 
   unsigned int numberOfExistingTools = m_ToolManager->GetTools().size();
 
   for (unsigned int i = 0; i < numberOfExistingTools; i++)
   {
     manualSegmentationTool = dynamic_cast<mitk::SegTool2D*>(m_ToolManager->GetToolById(i));
     if (nullptr == manualSegmentationTool)
     {
       continue;
     }
 
     manualSegmentationTool->SetShowMarkerNodes(state);
   }
 }
 
 void QmitkSegmentationView::OnLayersChanged()
 {
-  m_Controls->labelSetWidget->ResetAllTableWidgetItems();
-}
-
-void QmitkSegmentationView::OnLabelsChanged()
-{
+  this->OnEstablishLabelSetConnection();
   m_Controls->labelSetWidget->ResetAllTableWidgetItems();
 }
 
 void QmitkSegmentationView::OnShowLabelTable(bool value)
 {
   m_Controls->labelSetWidget->setVisible(value);
 }
 
 void QmitkSegmentationView::OnGoToLabel(const mitk::Point3D& pos)
 {
   if (m_RenderWindowPart)
   {
     m_RenderWindowPart->SetSelectedPosition(pos);
   }
 }
 
 void QmitkSegmentationView::OnLabelSetWidgetReset()
 {
   this->ValidateSelectionInput();
 }
 
 /**********************************************************************/
 /* private                                                            */
 /**********************************************************************/
 void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
 {
    m_Parent = parent;
 
    m_Controls = new Ui::QmitkSegmentationViewControls;
    m_Controls->setupUi(parent);
 
    // *------------------------
    // * SHORTCUTS
    // *------------------------
    QShortcut* visibilityShortcut = new QShortcut(QKeySequence("CTRL+H"), parent);
    connect(visibilityShortcut, &QShortcut::activated, this, &QmitkSegmentationView::OnVisibilityShortcutActivated);
    QShortcut* labelToggleShortcut = new QShortcut(QKeySequence("CTRL+L"), parent);
    connect(labelToggleShortcut, &QShortcut::activated, this, &QmitkSegmentationView::OnLabelToggleShortcutActivated);
 
    // *------------------------
    // * DATA SELECTION WIDGETS
    // *------------------------
    m_Controls->referenceNodeSelector->SetDataStorage(GetDataStorage());
    m_Controls->referenceNodeSelector->SetNodePredicate(m_ReferencePredicate);
    m_Controls->referenceNodeSelector->SetInvalidInfo("Select an image");
    m_Controls->referenceNodeSelector->SetPopUpTitel("Select an image");
    m_Controls->referenceNodeSelector->SetPopUpHint("Select an image that should be used to define the geometry and bounds of the segmentation.");
 
    m_Controls->workingNodeSelector->SetDataStorage(GetDataStorage());
    m_Controls->workingNodeSelector->SetNodePredicate(m_SegmentationPredicate);
    m_Controls->workingNodeSelector->SetInvalidInfo("Select a segmentation");
    m_Controls->workingNodeSelector->SetPopUpTitel("Select a segmentation");
    m_Controls->workingNodeSelector->SetPopUpHint("Select a segmentation that should be modified. Only segmentation with the same geometry and within the bounds of the reference image are selected.");
 
    connect(m_Controls->referenceNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
            this, &QmitkSegmentationView::OnReferenceSelectionChanged);
    connect(m_Controls->workingNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
            this, &QmitkSegmentationView::OnSegmentationSelectionChanged);
 
    // *------------------------
    // * TOOLMANAGER
    // *------------------------
    m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
    m_ToolManager->SetDataStorage(*(this->GetDataStorage()));
    m_ToolManager->InitializeTools();
 
    QString segTools2D = tr("Add Subtract Fill Erase Paint Wipe 'Region Growing' 'Live Wire'");
    QString segTools3D = tr("Threshold 'UL Threshold' Otsu 'Region Growing 3D' Picking");
 #ifdef __linux__
    segTools3D.append(" nnUNet"); // plugin not enabled for MacOS / Windows
 #endif
    std::regex extSegTool2DRegEx("SegTool2D$");
    std::regex extSegTool3DRegEx("SegTool3D$");
 
    auto tools = m_ToolManager->GetTools();
    for (const auto &tool : tools)
    {
      if (std::regex_search(tool->GetNameOfClass(), extSegTool2DRegEx))
      {
        segTools2D.append(QString(" '%1'").arg(tool->GetName()));
      }
      else if (std::regex_search(tool->GetNameOfClass(), extSegTool3DRegEx))
      {
        segTools3D.append(QString(" '%1'").arg(tool->GetName()));
      }
    }
 
    // setup 2D tools
    m_Controls->toolSelectionBox2D->SetToolManager(*m_ToolManager);
    m_Controls->toolSelectionBox2D->SetGenerateAccelerators(true);
    m_Controls->toolSelectionBox2D->SetToolGUIArea(m_Controls->toolGUIArea2D);
    m_Controls->toolSelectionBox2D->SetDisplayedToolGroups(segTools2D.toStdString());
    m_Controls->toolSelectionBox2D->SetLayoutColumns(3);
    m_Controls->toolSelectionBox2D->SetEnabledMode(
      QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
    connect(m_Controls->toolSelectionBox2D, &QmitkToolSelectionBox::ToolSelected,
            this, &QmitkSegmentationView::OnManualTool2DSelected);
 
    // setup 3D Tools
    m_Controls->toolSelectionBox3D->SetToolManager(*m_ToolManager);
    m_Controls->toolSelectionBox3D->SetGenerateAccelerators(true);
    m_Controls->toolSelectionBox3D->SetToolGUIArea(m_Controls->toolGUIArea3D);
    m_Controls->toolSelectionBox3D->SetDisplayedToolGroups(segTools3D.toStdString());
    m_Controls->toolSelectionBox3D->SetLayoutColumns(3);
    m_Controls->toolSelectionBox3D->SetEnabledMode(
      QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
 
    m_Controls->slicesInterpolator->SetDataStorage(this->GetDataStorage());
 
    // create general signal / slot connections
    connect(m_Controls->newSegmentationButton, &QToolButton::clicked, this, &QmitkSegmentationView::OnNewSegmentation);
    connect(m_Controls->slicesInterpolator, &QmitkSlicesInterpolator::SignalShowMarkerNodes, this, &QmitkSegmentationView::OnShowMarkerNodes);
 
    connect(m_Controls->layersWidget, &QmitkLayersWidget::LayersChanged, this, &QmitkSegmentationView::OnLayersChanged);
-   connect(m_Controls->labelsWidget, &QmitkLabelsWidget::LabelsChanged, this, &QmitkSegmentationView::OnLabelsChanged);
    connect(m_Controls->labelsWidget, &QmitkLabelsWidget::ShowLabelTable, this, &QmitkSegmentationView::OnShowLabelTable);
 
    // *------------------------
    // * LABELSETWIDGET
    // *------------------------
    connect(m_Controls->labelSetWidget, &QmitkLabelSetWidget::goToLabel, this, &QmitkSegmentationView::OnGoToLabel);
    connect(m_Controls->labelSetWidget, &QmitkLabelSetWidget::LabelSetWidgetReset, this, &QmitkSegmentationView::OnLabelSetWidgetReset);
 
    m_Controls->labelSetWidget->SetDataStorage(this->GetDataStorage());
-   m_Controls->labelSetWidget->SetOrganColors(mitk::OrganNamesHandling::GetDefaultOrganColorString());
    m_Controls->labelSetWidget->hide();
 
    auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
    command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
    m_RenderingManagerObserverTag =
      mitk::RenderingManager::GetInstance()->AddObserver(mitk::RenderingManagerViewsInitializedEvent(), command);
 
    m_RenderWindowPart = this->GetRenderWindowPart();
    if (nullptr != m_RenderWindowPart)
    {
      this->RenderWindowPartActivated(m_RenderWindowPart);
    }
 
    // Make sure the GUI notices if appropriate data is already present on creation.
    // Should be done last, if everything else is configured because it triggers the autoselection of data.
    m_Controls->referenceNodeSelector->SetAutoSelectNewNodes(true);
    m_Controls->workingNodeSelector->SetAutoSelectNewNodes(true);
 
    this->UpdateGUI();
 }
 
 void QmitkSegmentationView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart != renderWindowPart)
   {
     m_RenderWindowPart = renderWindowPart;
   }
 
   if (nullptr != m_Parent)
   {
     m_Parent->setEnabled(true);
   }
 
   if (nullptr == m_Controls)
   {
     return;
   }
 
   // tell the interpolation about tool manager, data storage and render window part
   if (nullptr != m_RenderWindowPart)
   {
     QList<mitk::SliceNavigationController*> controllers;
     controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
     m_Controls->slicesInterpolator->Initialize(m_ToolManager, controllers);
   }
 }
 
 void QmitkSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_RenderWindowPart = nullptr;
   if (nullptr != m_Parent)
   {
     m_Parent->setEnabled(false);
   }
 }
 
 void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
+  auto labelSuggestions = mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABEL_SUGGESTIONS.toStdString(), "");
+
+  m_DefaultLabelNaming = labelSuggestions.empty()
+    ? prefs->GetBool("default label naming", true)
+    : false; // No default label naming when label suggestions are enforced via command-line argument
+
   if (nullptr != m_Controls)
   {
+    m_Controls->labelsWidget->SetDefaultLabelNaming(m_DefaultLabelNaming);
+
     bool slimView = prefs->GetBool("slim view", false);
     m_Controls->toolSelectionBox2D->SetShowNames(!slimView);
     m_Controls->toolSelectionBox3D->SetShowNames(!slimView);
   }
 
   m_DrawOutline = prefs->GetBool("draw outline", true);
   m_SelectionMode = prefs->GetBool("selection mode", false);
 
   m_LabelSetPresetPreference = prefs->Get("label set preset", "");
 
   this->ApplyDisplayOptions();
 }
 
 void QmitkSegmentationView::NodeAdded(const mitk::DataNode* node)
 {
   if (m_SegmentationPredicate->CheckNode(node))
   {
     this->ApplyDisplayOptions(const_cast<mitk::DataNode*>(node));
   }
 }
 
 void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
 {
   if (!m_SegmentationPredicate->CheckNode(node))
   {
     return;
   }
 
   // remove all possible contour markers of the segmentation
   mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(
     node, mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
 
   ctkPluginContext* context = mitk::PluginActivator::getContext();
   ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
   mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
 
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
   {
     std::string nodeName = node->GetName();
     unsigned int t = nodeName.find_last_of(" ");
     unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
 
     service->RemovePlanePosition(id);
 
     this->GetDataStorage()->Remove(it->Value());
   }
 
   context->ungetService(ppmRef);
   service = nullptr;
 
   mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
   mitk::SurfaceInterpolationController::GetInstance()->RemoveInterpolationSession(image);
 }
 
 void QmitkSegmentationView::OnEstablishLabelSetConnection()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
 
   auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
   if (nullptr == workingImage)
   {
     return;
   }
 
   workingImage->GetActiveLabelSet()->AddLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->RemoveLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ModifyLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ActiveLabelEvent += mitk::MessageDelegate1<QmitkLabelSetWidget,
     mitk::Label::PixelType>(m_Controls->labelSetWidget, &QmitkLabelSetWidget::SelectLabelByPixelValue);
 
   // Removed in T27851 to have a chance to react to AfterChangeLayerEvent. Did it brake something?
   // workingImage->BeforeChangeLayerEvent += mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
   //   this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
 
   workingImage->AfterChangeLayerEvent += mitk::MessageDelegate<QmitkSegmentationView>(
     this, &QmitkSegmentationView::UpdateGUI);
 }
 
 void QmitkSegmentationView::OnLooseLabelSetConnection()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
 
   auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
   if (nullptr == workingImage)
   {
     return;
   }
 
   // Reset LabelSetWidget Events
   workingImage->GetActiveLabelSet()->AddLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->RemoveLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ModifyLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ActiveLabelEvent -= mitk::MessageDelegate1<QmitkLabelSetWidget,
     mitk::Label::PixelType>(m_Controls->labelSetWidget, &QmitkLabelSetWidget::SelectLabelByPixelValue);
 
   // Removed in T27851 to have a chance to react to AfterChangeLayerEvent. Did it brake something?
   // workingImage->BeforeChangeLayerEvent -= mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
   //   this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
 
   workingImage->AfterChangeLayerEvent -= mitk::MessageDelegate<QmitkSegmentationView>(
     this, &QmitkSegmentationView::UpdateGUI);
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions()
 {
   if (nullptr == m_Parent)
   {
     return;
   }
 
   if (nullptr == m_Controls)
   {
     return; // might happen on initialization (preferences loaded)
   }
 
   mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
   for (mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
   {
     this->ApplyDisplayOptions(*iter);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
 {
   if (nullptr == node)
   {
     return;
   }
 
   auto labelSetImage = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
   if (nullptr != labelSetImage)
   {
     // node is a multi label segmentation
     // its outline property can be set in the segmentation preference page
     node->SetProperty("labelset.contour.active", mitk::BoolProperty::New(m_DrawOutline));
 
     // force render window update to show outline
     node->GetData()->Modified();
   }
   else if (nullptr != node->GetData())
   {
     // node is a legacy binary segmentation
     bool isBinary = false;
     node->GetBoolProperty("binary", isBinary);
     if (isBinary)
     {
       node->SetProperty("outline binary", mitk::BoolProperty::New(m_DrawOutline));
       node->SetProperty("outline width", mitk::FloatProperty::New(2.0));
       // force render window update to show outline
       node->GetData()->Modified();
     }
   }
 }
 
 void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode* node)
 {
   QmitkRenderWindow* selectedRenderWindow = nullptr;
   auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
   auto* axialRenderWindow = renderWindowPart->GetQmitkRenderWindow("axial");
   auto* sagittalRenderWindow = renderWindowPart->GetQmitkRenderWindow("sagittal");
   auto* coronalRenderWindow = renderWindowPart->GetQmitkRenderWindow("coronal");
   auto* threeDRenderWindow = renderWindowPart->GetQmitkRenderWindow("3d");
   bool PlanarFigureInitializedWindow = false;
 
   // find initialized renderwindow
   if (node->GetBoolProperty("PlanarFigureInitializedWindow",
     PlanarFigureInitializedWindow, axialRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = axialRenderWindow;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     sagittalRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = sagittalRenderWindow;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     coronalRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = coronalRenderWindow;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     threeDRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = threeDRenderWindow;
   }
 
   // make node visible
   if (nullptr != selectedRenderWindow)
   {
     std::string nodeName = node->GetName();
     unsigned int t = nodeName.find_last_of(" ");
     unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
 
     ctkPluginContext* context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
     selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
     context->ungetService(ppmRef);
 
     selectedRenderWindow->GetRenderer()->GetCameraController()->Fit();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSegmentationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   if (0 == nodes.size())
   {
     return;
   }
 
   std::string markerName = "Position";
   unsigned int numberOfNodes = nodes.size();
   std::string nodeName = nodes.at(0)->GetName();
   if ((numberOfNodes == 1) && (nodeName.find(markerName) == 0))
   {
     this->OnContourMarkerSelected(nodes.at(0));
     return;
   }
 }
 
 void QmitkSegmentationView::ResetMouseCursor()
 {
   if (m_MouseCursorSet)
   {
     mitk::ApplicationCursor::GetInstance()->PopCursor();
     m_MouseCursorSet = false;
   }
 }
 
 void QmitkSegmentationView::SetMouseCursor(const us::ModuleResource& resource, int hotspotX, int hotspotY)
 {
   // Remove previously set mouse cursor
   if (m_MouseCursorSet)
   {
     this->ResetMouseCursor();
   }
 
   if (resource)
   {
     us::ModuleResourceStream cursor(resource, std::ios::binary);
     mitk::ApplicationCursor::GetInstance()->PushCursor(cursor, hotspotX, hotspotY);
     m_MouseCursorSet = true;
   }
 }
 
 void QmitkSegmentationView::UpdateGUI()
 {
   mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
   bool hasReferenceNode = referenceNode != nullptr;
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   bool hasWorkingNode = workingNode != nullptr;
 
   m_Controls->newSegmentationButton->setEnabled(false);
 
   if (hasReferenceNode)
   {
     m_Controls->newSegmentationButton->setEnabled(true);
   }
 
   if (hasWorkingNode && hasReferenceNode)
   {
     int layer = -1;
     referenceNode->GetIntProperty("layer", layer);
     workingNode->SetIntProperty("layer", layer + 1);
   }
 
   m_Controls->layersWidget->UpdateGUI();
   m_Controls->labelsWidget->UpdateGUI();
 
   this->ValidateSelectionInput();
 }
 
 void QmitkSegmentationView::ValidateSelectionInput()
 {
   this->UpdateWarningLabel("");
 
   m_Controls->layersWidget->setEnabled(false);
   m_Controls->labelsWidget->setEnabled(false);
   m_Controls->labelSetWidget->setEnabled(false);
 
   // the argument is actually not used
   // enable status depends on the tool manager selection
   m_Controls->toolSelectionBox2D->setEnabled(false);
   m_Controls->toolSelectionBox3D->setEnabled(false);
   m_Controls->slicesInterpolator->setEnabled(false);
   m_Controls->interpolatorWarningLabel->hide();
 
   mitk::DataNode* referenceNode = m_Controls->referenceNodeSelector->GetSelectedNode();
   mitk::DataNode* workingNode = m_Controls->workingNodeSelector->GetSelectedNode();
 
   if (nullptr == referenceNode)
   {
     return;
   }
 
   if (nullptr == workingNode)
   {
     return;
   }
 
   mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
   auto workingNodeIsVisible = renderWindowPart &&
     workingNode->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer());
   if (!workingNodeIsVisible)
   {
     this->UpdateWarningLabel(tr("The selected segmentation is currently not visible!"));
     return;
   }
 
   /*
   * Here we check whether the geometry of the selected segmentation image is aligned with the worldgeometry.
   * At the moment it is not supported to use a geometry different from the selected image for reslicing.
   * For further information see Bug 16063
   */
   const mitk::BaseGeometry* workingNodeGeo = workingNode->GetData()->GetGeometry();
   const mitk::BaseGeometry* worldGeo =
     renderWindowPart->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
   if (nullptr != workingNodeGeo && nullptr != worldGeo)
   {
     if (mitk::Equal(*workingNodeGeo->GetBoundingBox(), *worldGeo->GetBoundingBox(), mitk::eps, true))
     {
       m_ToolManager->SetReferenceData(referenceNode);
       m_ToolManager->SetWorkingData(workingNode);
       m_Controls->layersWidget->setEnabled(true);
       m_Controls->labelsWidget->setEnabled(true);
       m_Controls->labelSetWidget->setEnabled(true);
       m_Controls->toolSelectionBox2D->setEnabled(true);
       m_Controls->toolSelectionBox3D->setEnabled(true);
 
       auto labelSetImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
       if (nullptr != labelSetImage)
       {
         int numberOfLabels = labelSetImage->GetNumberOfLabels(labelSetImage->GetActiveLayer());
         if (2 == numberOfLabels) // fix for T27319: exterior is label 0, first label is label 1
         {
           m_Controls->slicesInterpolator->setEnabled(true);
         }
         else
         {
           m_Controls->interpolatorWarningLabel->show();
           m_Controls->interpolatorWarningLabel->setText("<font color=\"red\">Interpolation only works for single label segmentations.</font>");
         }
       }
       return;
     }
   }
 
   m_ToolManager->SetReferenceData(referenceNode);
   m_ToolManager->SetWorkingData(nullptr);
   this->UpdateWarningLabel(tr("Please perform a reinit on the segmentation image!"));
 }
 
 void QmitkSegmentationView::UpdateWarningLabel(QString text)
 {
   if (text.size() == 0)
   {
     m_Controls->selectionWarningLabel->hide();
   }
   else
   {
     m_Controls->selectionWarningLabel->show();
     m_Controls->selectionWarningLabel->setText("<font color=\"red\">" + text + "</font>");
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
index d1e0a97ff1..7874805f2d 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
@@ -1,154 +1,153 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKSEGMENTATIONVIEW_H
 #define QMITKSEGMENTATIONVIEW_H
 
 #include "ui_QmitkSegmentationViewControls.h"
 
 #include <QmitkAbstractView.h>
 #include <mitkIRenderWindowPartListener.h>
 
 #include <berryIBerryPreferences.h>
 
 /**
 * @brief The segmentation view provides a set of tool to use different segmentation algorithms.
 *        It provides two selection widgets to load an image node and a segmentation node
 *        on which to perform the segmentation. Creating new segmentation nodes is also possible.
 *        The available segmentation tools are grouped into "2D"- and "3D"-tools.
 *
 *        Most segmentation tools / algorithms need some kind of user interaction, where the
 *        user is asked to draw something in the image display or set some seed points / start values.
 *        The tools also often provide additional propeties so that a user can modify the
 *        algorithm's behavior.
 *
 *        This class additionally provides options to work with different layers (create new layers,
 *        switch between layers).
 *        Moreover, a multilabel widget displays all the existing labels of a multilabel segmentation
 *        for the currently active layer.
 *        The multilabel widget allows to control the labels by creatin new one, removing existing ones,
 *        showing / hiding single labels, merging labels, (re-)naming them etc.
 *
 *        Additionally the view provides an option to create "2D"- and "3D"-interpolations between
 *        neighboring segmentation masks on unsegmented slices.
 *        Interpolation for multilabel segmentations is currently not implemented.
 */
 class QmitkSegmentationView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkSegmentationView();
   ~QmitkSegmentationView() override;
 
 private Q_SLOTS:
 
   // reaction to the selection of a new reference image in the selection widget
   void OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
 
   // reaction to the selection of a new segmentation image in the selection widget
   void OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
 
   // reaction to the shortcut ("CTRL+H") for toggling the visibility of the working node
   void OnVisibilityShortcutActivated();
 
   // reaction to the shortcut ("CTRL+L") for iterating over all labels
   void OnLabelToggleShortcutActivated();
 
   // reaction to the button "New segmentation"
   void OnNewSegmentation();
 
   void OnManualTool2DSelected(int id);
 
   void OnShowMarkerNodes(bool);
 
   void OnLayersChanged();
 
-  void OnLabelsChanged();
-
   void OnShowLabelTable(bool);
 
   void OnGoToLabel(const mitk::Point3D &pos);
 
   void OnLabelSetWidgetReset();
 
 private:
 
   void CreateQtPartControl(QWidget* parent) override;
 
   void SetFocus() override {}
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
   void OnPreferencesChanged(const berry::IBerryPreferences* prefs) override;
 
   void NodeAdded(const mitk::DataNode* node) override;
 
   void NodeRemoved(const mitk::DataNode* node) override;
 
   void OnEstablishLabelSetConnection();
 
   void OnLooseLabelSetConnection();
 
   // make sure all images / segmentations look according to the user preference settings
   void ApplyDisplayOptions();
 
   // decorates a DataNode according to the user preference settings
   void ApplyDisplayOptions(mitk::DataNode* node);
 
   // If a contourmarker is selected, the plane in the related widget will be reoriented according to the marker`s geometry
   void OnContourMarkerSelected(const mitk::DataNode* node);
 
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes) override;
 
   void ResetMouseCursor();
 
   void SetMouseCursor(const us::ModuleResource&, int hotspotX, int hotspotY);
 
   void UpdateGUI();
 
   void ValidateSelectionInput();
 
   void UpdateWarningLabel(QString text);
 
   std::string GetDefaultLabelSetPreset() const;
 
   QWidget* m_Parent;
 
   Ui::QmitkSegmentationViewControls* m_Controls;
 
   mitk::IRenderWindowPart* m_RenderWindowPart;
 
   mitk::ToolManager* m_ToolManager;
 
   mitk::DataNode::Pointer m_ReferenceNode;
   mitk::DataNode::Pointer m_WorkingNode;
 
   typedef std::map<mitk::DataNode*, unsigned long> NodeTagMapType;
   NodeTagMapType m_WorkingDataObserverTags;
   unsigned int m_RenderingManagerObserverTag;
 
   mitk::NodePredicateAnd::Pointer m_ReferencePredicate;
   mitk::NodePredicateAnd::Pointer m_SegmentationPredicate;
 
   bool m_DrawOutline;
   bool m_SelectionMode;
   bool m_MouseCursorSet;
 
   QString m_LabelSetPresetPreference;
+  bool m_DefaultLabelNaming;
 };
 
 #endif // QMITKSEGMENTATIONVIEW_H
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.cpp
index d67b951f87..5a15febb83 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.cpp
@@ -1,251 +1,251 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkMorphologicalOperationsWidget.h"
 #include <mitkProgressBar.h>
 #include <mitkSliceNavigationController.h>
 #include <QCheckBox>
 
 static const char* const HelpText = "Select a segmentation above";
 
 QmitkMorphologicalOperationsWidget::QmitkMorphologicalOperationsWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent)
   : QmitkSegmentationUtilityWidget(timeNavigationController, parent)
 {
   m_Controls.setupUi(this);
 
   m_Controls.dataSelectionWidget->AddDataSelection(QmitkDataSelectionWidget::SegmentationPredicate);
   m_Controls.dataSelectionWidget->SetHelpText(HelpText);
 
   connect(m_Controls.btnClosing, SIGNAL(clicked()), this, SLOT(OnClosingButtonClicked()));
   connect(m_Controls.btnOpening, SIGNAL(clicked()), this, SLOT(OnOpeningButtonClicked()));
   connect(m_Controls.btnDilatation, SIGNAL(clicked()), this, SLOT(OnDilatationButtonClicked()));
   connect(m_Controls.btnErosion, SIGNAL(clicked()), this, SLOT(OnErosionButtonClicked()));
   connect(m_Controls.btnFillHoles, SIGNAL(clicked()), this, SLOT(OnFillHolesButtonClicked()));
   connect(m_Controls.radioButtonMorphoCross, SIGNAL(clicked()), this, SLOT(OnRadioButtonsClicked()));
   connect(m_Controls.radioButtonMorphoBall, SIGNAL(clicked()), this, SLOT(OnRadioButtonsClicked()));
   connect(m_Controls.dataSelectionWidget, SIGNAL(SelectionChanged(unsigned int, const mitk::DataNode*)), this, SLOT(OnSelectionChanged(unsigned int, const mitk::DataNode*)));
 
   if (m_Controls.dataSelectionWidget->GetSelection(0).IsNotNull())
     this->OnSelectionChanged(0, m_Controls.dataSelectionWidget->GetSelection(0));
 }
 
 QmitkMorphologicalOperationsWidget::~QmitkMorphologicalOperationsWidget()
 {
 }
 
 void QmitkMorphologicalOperationsWidget::OnSelectionChanged(unsigned int, const mitk::DataNode*)
 {
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node = dataSelectionWidget->GetSelection(0);
 
   if (node.IsNotNull())
   {
     m_Controls.dataSelectionWidget->SetHelpText("");
     this->EnableButtons(true);
   }
   else
   {
     m_Controls.dataSelectionWidget->SetHelpText(HelpText);
     this->EnableButtons(false);
   }
 }
 
 void QmitkMorphologicalOperationsWidget::EnableButtons(bool enable)
 {
   m_Controls.btnClosing->setEnabled(enable);
   m_Controls.btnDilatation->setEnabled(enable);
   m_Controls.btnErosion->setEnabled(enable);
   m_Controls.btnFillHoles->setEnabled(enable);
   m_Controls.btnOpening->setEnabled(enable);
 }
 
 void QmitkMorphologicalOperationsWidget::OnRadioButtonsClicked()
 {
   bool enable = m_Controls.radioButtonMorphoBall->isChecked();
 
   m_Controls.sliderMorphFactor->setEnabled(enable);
   m_Controls.spinBoxMorphFactor->setEnabled(enable);
 }
 
 void QmitkMorphologicalOperationsWidget::OnClosingButtonClicked()
 {
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node = dataSelectionWidget->GetSelection(0);
   mitk::Image::Pointer image = static_cast<mitk::Image*>(node->GetData());
   mitk::MorphologicalOperations::StructuralElementType structuralElement = CreateStructerElement_UI();
   try
   {
     int factor = m_Controls.spinBoxMorphFactor->isEnabled()
       ? m_Controls.spinBoxMorphFactor->value()
       : 1;
 
     mitk::MorphologicalOperations::Closing(image, factor, structuralElement);
   }
   catch (const itk::ExceptionObject& exception)
   {
     MITK_WARN << "Exception caught: " << exception.GetDescription();
 
     QApplication::restoreOverrideCursor();
     return;
   }
 
   node->SetData(image);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkMorphologicalOperationsWidget::OnOpeningButtonClicked()
 {
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node = dataSelectionWidget->GetSelection(0);
   mitk::Image::Pointer image = static_cast<mitk::Image*>(node->GetData());
 
   mitk::MorphologicalOperations::StructuralElementType structuralElement = CreateStructerElement_UI();
 
   try
   {
     int factor = m_Controls.spinBoxMorphFactor->isEnabled()
       ? m_Controls.spinBoxMorphFactor->value()
       : 1;
 
      mitk::MorphologicalOperations::Opening(image, factor, structuralElement);
   }
   catch (const itk::ExceptionObject& exception)
   {
      MITK_WARN << "Exception caught: " << exception.GetDescription();
 
      QApplication::restoreOverrideCursor();
      return;
   }
 
   node->SetData(image);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkMorphologicalOperationsWidget::OnDilatationButtonClicked()
 {
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node = dataSelectionWidget->GetSelection(0);
   mitk::Image::Pointer image = static_cast<mitk::Image*>(node->GetData());
   mitk::MorphologicalOperations::StructuralElementType structuralElement = this->CreateStructerElement_UI();
 
   try
   {
     int factor = m_Controls.spinBoxMorphFactor->isEnabled()
       ? m_Controls.spinBoxMorphFactor->value()
       : 1;
 
     mitk::MorphologicalOperations::Dilate(image, factor, structuralElement);
   }
   catch (const itk::ExceptionObject& exception)
   {
     MITK_WARN << "Exception caught: " << exception.GetDescription();
 
     QApplication::restoreOverrideCursor();
     return;
   }
 
   node->SetData(image);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkMorphologicalOperationsWidget::OnErosionButtonClicked()
 {
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node = dataSelectionWidget->GetSelection(0);
   mitk::Image::Pointer image = static_cast<mitk::Image*>(node->GetData());
 mitk::MorphologicalOperations::StructuralElementType structuralElement = CreateStructerElement_UI();
 
   try
   {
     int factor = m_Controls.spinBoxMorphFactor->isEnabled()
       ? m_Controls.spinBoxMorphFactor->value()
       : 1;
 
     mitk::MorphologicalOperations::Erode(image, factor, structuralElement);
   }
   catch (const itk::ExceptionObject& exception)
   {
     MITK_WARN << "Exception caught: " << exception.GetDescription();
 
     QApplication::restoreOverrideCursor();
     return;
  }
 
   node->SetData(image);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkMorphologicalOperationsWidget::OnFillHolesButtonClicked()
 {
   QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node = dataSelectionWidget->GetSelection(0);
   mitk::Image::Pointer image = static_cast<mitk::Image*>(node->GetData());
 
   try
   {
     mitk::MorphologicalOperations::FillHoles(image);
   }
   catch (const itk::ExceptionObject& exception)
   {
     MITK_WARN << "Exception caught: " << exception.GetDescription();
 
     QApplication::restoreOverrideCursor();
     return;
   }
 
   node->SetData(image);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QApplication::restoreOverrideCursor();
 }
 
 
 mitk::MorphologicalOperations::StructuralElementType QmitkMorphologicalOperationsWidget::CreateStructerElement_UI()
 {
   bool ball = m_Controls.radioButtonMorphoBall->isChecked();
   int accum_flag = 0;
   if(ball){
    if(m_Controls.planeSelectionComboBox->currentIndex() == 0) accum_flag = mitk::MorphologicalOperations::Ball; // 3D Operation
    if(m_Controls.planeSelectionComboBox->currentIndex() == 1) accum_flag = mitk::MorphologicalOperations::Ball_Axial; // 2D Operation - Axial plane
-   if(m_Controls.planeSelectionComboBox->currentIndex() == 2) accum_flag = mitk::MorphologicalOperations::Ball_Sagital; // 2D Operation - Sagital plane
+   if(m_Controls.planeSelectionComboBox->currentIndex() == 2) accum_flag = mitk::MorphologicalOperations::Ball_Sagittal; // 2D Operation - Sagittal plane
    if(m_Controls.planeSelectionComboBox->currentIndex() == 3) accum_flag = mitk::MorphologicalOperations::Ball_Coronal; // 2D Operation - Coronal plane
   }else{
     if(m_Controls.planeSelectionComboBox->currentIndex() == 0) accum_flag = mitk::MorphologicalOperations::Cross;
     if(m_Controls.planeSelectionComboBox->currentIndex() == 1) accum_flag = mitk::MorphologicalOperations::Cross_Axial;
-    if(m_Controls.planeSelectionComboBox->currentIndex() == 2) accum_flag = mitk::MorphologicalOperations::Cross_Sagital;
+    if(m_Controls.planeSelectionComboBox->currentIndex() == 2) accum_flag = mitk::MorphologicalOperations::Cross_Sagittal;
     if(m_Controls.planeSelectionComboBox->currentIndex() == 3) accum_flag = mitk::MorphologicalOperations::Cross_Coronal;
   }
   return (mitk::MorphologicalOperations::StructuralElementType)accum_flag;
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidgetControls.ui b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidgetControls.ui
index 0d1c003d6c..b328a3b7ad 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidgetControls.ui
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidgetControls.ui
@@ -1,323 +1,323 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkMorphologicalOperationsWidgetControls</class>
  <widget class="QWidget" name="QmitkMorphologicalOperationsWidgetControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>184</width>
     <height>377</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QmitkDataSelectionWidget" name="dataSelectionWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_6">
      <property name="title">
       <string>Structuring Element</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <widget class="QRadioButton" name="radioButtonMorphoBall">
         <property name="text">
          <string>Ball</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QRadioButton" name="radioButtonMorphoCross">
         <property name="text">
          <string>Cross</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QComboBox" name="planeSelectionComboBox">
         <item>
          <property name="text">
           <string>3D Operation</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>2D Operation - Axial</string>
          </property>
         </item>
         <item>
          <property name="text">
-          <string>2D Operation - Sagital</string>
+          <string>2D Operation - Sagittal</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>2D Operation - Coronal</string>
          </property>
         </item>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QLabel" name="label">
        <property name="text">
         <string>Radius</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QSlider" name="sliderMorphFactor">
        <property name="minimum">
         <number>1</number>
        </property>
        <property name="maximum">
         <number>20</number>
        </property>
        <property name="pageStep">
         <number>1</number>
        </property>
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QSpinBox" name="spinBoxMorphFactor">
        <property name="minimum">
         <number>1</number>
        </property>
        <property name="maximum">
         <number>20</number>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QGridLayout" name="gridLayout">
      <item row="0" column="0">
       <widget class="QToolButton" name="btnDilatation">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Dilation</string>
        </property>
        <property name="icon">
         <iconset resource="../../../../resources/MorphologicalOperationsWidget.qrc">
          <normaloff>:/SegmentationUtilities/MorphologicalOperations/Dilate_48x48.png</normaloff>:/SegmentationUtilities/MorphologicalOperations/Dilate_48x48.png</iconset>
        </property>
        <property name="iconSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
        <property name="toolButtonStyle">
         <enum>Qt::ToolButtonTextUnderIcon</enum>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QToolButton" name="btnErosion">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Erosion</string>
        </property>
        <property name="icon">
         <iconset resource="../../../../resources/MorphologicalOperationsWidget.qrc">
          <normaloff>:/SegmentationUtilities/MorphologicalOperations/Erode_48x48.png</normaloff>:/SegmentationUtilities/MorphologicalOperations/Erode_48x48.png</iconset>
        </property>
        <property name="iconSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
        <property name="toolButtonStyle">
         <enum>Qt::ToolButtonTextUnderIcon</enum>
        </property>
       </widget>
      </item>
      <item row="1" column="0">
       <widget class="QToolButton" name="btnClosing">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Closing</string>
        </property>
        <property name="icon">
         <iconset resource="../../../../resources/MorphologicalOperationsWidget.qrc">
          <normaloff>:/SegmentationUtilities/MorphologicalOperations/Closing_48x48.png</normaloff>:/SegmentationUtilities/MorphologicalOperations/Closing_48x48.png</iconset>
        </property>
        <property name="iconSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
        <property name="toolButtonStyle">
         <enum>Qt::ToolButtonTextUnderIcon</enum>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="QToolButton" name="btnOpening">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Opening</string>
        </property>
        <property name="icon">
         <iconset resource="../../../../resources/MorphologicalOperationsWidget.qrc">
          <normaloff>:/SegmentationUtilities/MorphologicalOperations/Opening_48x48.png</normaloff>:/SegmentationUtilities/MorphologicalOperations/Opening_48x48.png</iconset>
        </property>
        <property name="iconSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
        <property name="toolButtonStyle">
         <enum>Qt::ToolButtonTextUnderIcon</enum>
        </property>
       </widget>
      </item>
      <item row="2" column="0">
       <widget class="QToolButton" name="btnFillHoles">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
         <string>Globally fills holes in segmentation (structuring element and radius not required)</string>
        </property>
        <property name="text">
         <string>Fill Holes</string>
        </property>
        <property name="icon">
         <iconset resource="../../../../resources/MorphologicalOperationsWidget.qrc">
          <normaloff>:/SegmentationUtilities/MorphologicalOperations/FillHoles_48x48.png</normaloff>:/SegmentationUtilities/MorphologicalOperations/FillHoles_48x48.png</iconset>
        </property>
        <property name="iconSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
        <property name="toolButtonStyle">
         <enum>Qt::ToolButtonTextUnderIcon</enum>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataSelectionWidget</class>
    <extends>QWidget</extends>
    <header>internal/Common/QmitkDataSelectionWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="../../../../resources/MorphologicalOperationsWidget.qrc"/>
  </resources>
  <connections>
   <connection>
    <sender>sliderMorphFactor</sender>
    <signal>valueChanged(int)</signal>
    <receiver>spinBoxMorphFactor</receiver>
    <slot>setValue(int)</slot>
    <hints>
     <hint type="sourcelabel">
      <x>240</x>
      <y>27</y>
     </hint>
     <hint type="destinationlabel">
      <x>766</x>
      <y>36</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>spinBoxMorphFactor</sender>
    <signal>valueChanged(int)</signal>
    <receiver>sliderMorphFactor</receiver>
    <slot>setValue(int)</slot>
    <hints>
     <hint type="sourcelabel">
      <x>784</x>
      <y>38</y>
     </hint>
     <hint type="destinationlabel">
      <x>657</x>
      <y>38</y>
     </hint>
    </hints>
   </connection>
  </connections>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.semanticrelations/manifest_headers.cmake
index 9da36a3fbc..a413decc69 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Semantic relations")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "DKFZ")
 set(Plugin-ContactAddress "http://www.mitk.org")
-set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.application)
+set(Require-Plugin org.mitk.gui.qt.common org.mitk.gui.qt.application org.mitk.gui.qt.segmentation)
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.cpp
index 536ddcc254..e587cb8cc3 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeAddToSemanticRelationsAction.cpp
@@ -1,247 +1,249 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations plugin
 #include "QmitkDataNodeAddToSemanticRelationsAction.h"
 #include "QmitkDataNodeRemoveFromSemanticRelationsAction.h"
 
 // semantic relations module
 #include <mitkControlPointManager.h>
 #include <mitkDICOMHelper.h>
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationsDataStorageAccess.h>
 #include <mitkSemanticRelationsInference.h>
 #include <mitkSemanticRelationsIntegration.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkRelationStorage.h>
 #include <mitkUIDGeneratorBoost.h>
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // mitk core
 #include <mitkTemporoSpatialStringProperty.h>
 
 // qt
 #include <QMessageBox>
 
 // namespace that contains the concrete action
 namespace AddToSemanticRelationsAction
 {
   void Run(mitk::DataStorage* dataStorage, const mitk::DataNode* dataNode)
   {
     if (nullptr == dataStorage
      || nullptr == dataNode)
     {
       return;
     }
 
     if (mitk::NodePredicates::GetImagePredicate()->CheckNode(dataNode))
     {
       try
       {
         AddImage(dataStorage, dataNode);
       }
       catch (mitk::SemanticRelationException& e)
       {
         mitkReThrow(e);
       }
     }
     else if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
     {
       try
       {
         AddSegmentation(dataStorage, dataNode);
       }
       catch (mitk::SemanticRelationException& e)
       {
         mitkReThrow(e);
       }
     }
   }
 
   void AddImage(mitk::DataStorage* dataStorage, const mitk::DataNode* image)
   {
     mitk::SemanticTypes::InformationType informationType;
     mitk::SemanticTypes::ExaminationPeriod examinationPeriod;
     mitk::SemanticRelationsDataStorageAccess::DataNodeVector allSpecificImages;
     try
     {
       mitk::SemanticTypes::CaseID caseID = GetCaseIDFromDataNode(image);
       informationType = GetDICOMModalityFromDataNode(image);
       // see if the examination period - information type cell is already taken
       examinationPeriod = FindFittingExaminationPeriod(image);
       auto semanticRelationsDataStorageAccess = mitk::SemanticRelationsDataStorageAccess(dataStorage);
       try
       {
         allSpecificImages = semanticRelationsDataStorageAccess.GetAllSpecificImages(caseID, informationType, examinationPeriod);
       }
       catch (const mitk::SemanticRelationException&)
       {
         // just continue since an exception means that there is no specific image
       }
     }
     catch (mitk::SemanticRelationException& e)
     {
       mitkReThrow(e);
     }
 
     if (!allSpecificImages.empty())
     {
       // examination period - information type cell is already taken
       // ask if cell should be overwritten
       QMessageBox::StandardButton answerButton =
         QMessageBox::question(nullptr,
           "Specific image already exists.",
           QString::fromStdString("Force overwriting existing image " + informationType + " at " + examinationPeriod.name + "?"),
           QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
       if (answerButton == QMessageBox::Yes)
       {
         try
         {
           // remove already existent images at specific cell
           for (const auto& specificImage : allSpecificImages)
           {
             RemoveFromSemanticRelationsAction::Run(dataStorage, specificImage);
           }
         }
         catch (mitk::SemanticRelationException& e)
         {
           mitkReThrow(e);
           return;
         }
       }
       else
       {
         // else case is: no overwriting
         return;
       }
     }
 
     // specific image does not exist or has been removed; adding the image should work
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
     try
     {
       semanticRelationsIntegration.AddImage(image);
     }
     catch (mitk::SemanticRelationException& e)
     {
       mitkReThrow(e);
     }
   }
 
   void AddSegmentation(mitk::DataStorage* dataStorage, const mitk::DataNode* segmentation)
   {
     if (nullptr == segmentation)
     {
       return;
     }
 
     mitk::BaseData* baseData = segmentation->GetData();
     if (nullptr == baseData)
     {
       return;
     }
 
     // continue with valid segmentation data
     // get parent node of the current segmentation node with the node predicate
     mitk::DataStorage::SetOfObjects::ConstPointer parentNodes = dataStorage->GetSources(segmentation, mitk::NodePredicates::GetImagePredicate(), false);
     if (parentNodes->empty())
     {
       // segmentation without corresponding image will not be added
       QMessageBox msgBox(QMessageBox::Warning,
         "Could not add the selected segmentation.",
         "The program wasn't able to correctly add the selected segmentation.\n"
         "Reason: No parent image found");
       msgBox.exec();
       return;
     }
 
     // check for already existing, identifying base properties
     auto caseIDPropertyName = mitk::GetCaseIDDICOMProperty();
     auto nodeIDPropertyName = mitk::GetNodeIDDICOMProperty();
     mitk::BaseProperty* caseIDProperty = baseData->GetProperty(caseIDPropertyName.c_str());
     mitk::BaseProperty* nodeIDProperty = baseData->GetProperty(nodeIDPropertyName.c_str());
     if (nullptr == caseIDProperty || nullptr == nodeIDProperty)
     {
       MITK_INFO << "No DICOM tags for case and node identification found. Transferring DICOM tags from the parent node to the selected segmentation node.";
 
       mitk::SemanticTypes::CaseID caseID;
       mitk::SemanticTypes::ID nodeID;
       try
       {
         caseID = mitk::GetCaseIDFromDataNode(parentNodes->front());
         nodeID = mitk::GetIDFromDataNode(parentNodes->front());
       }
       catch (mitk::SemanticRelationException& e)
       {
         mitkReThrow(e);
         return;
       }
 
       // transfer DICOM tags to the segmentation node
       baseData->SetProperty(caseIDPropertyName, mitk::TemporoSpatialStringProperty::New(caseID));
       // add UID to distinguish between different segmentations of the same parent node
       baseData->SetProperty(nodeIDPropertyName, mitk::TemporoSpatialStringProperty::New(nodeID + mitk::UIDGeneratorBoost::GenerateUID()));
     }
 
     // add the parent node if not already existent
     if (!mitk::SemanticRelationsInference::InstanceExists(parentNodes->front()))
     {
       AddImage(dataStorage, parentNodes->front());
     }
 
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
     try
     {
       // add the segmentation with its parent image to the semantic relations storage
       semanticRelationsIntegration.AddSegmentation(segmentation, parentNodes->front());
     }
     catch (mitk::SemanticRelationException& e)
     {
       mitkReThrow(e);
     }
   }
 }
 
 QmitkDataNodeAddToSemanticRelationsAction::QmitkDataNodeAddToSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchPartSite)
 {
   setText(tr("Add to semantic relations"));
   InitializeAction();
 }
 
 QmitkDataNodeAddToSemanticRelationsAction::QmitkDataNodeAddToSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Add to semantic relations"));
   InitializeAction();
 }
 
 void QmitkDataNodeAddToSemanticRelationsAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkDataNodeAddToSemanticRelationsAction::OnActionTriggered);
 }
 
 void QmitkDataNodeAddToSemanticRelationsAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
   auto dataNode = GetSelectedNode();
-  AddToSemanticRelationsAction::Run(m_DataStorage.Lock(), dataNode);
+  AddToSemanticRelationsAction::Run(dataStorage, dataNode);
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.cpp
index 902647c973..e7b33a31a6 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeRemoveFromSemanticRelationsAction.cpp
@@ -1,127 +1,129 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations plugin
 #include "QmitkDataNodeRemoveFromSemanticRelationsAction.h"
 
 // semantic relations module
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsIntegration.h>
 
 // mitk gui common plugin
 #include <mitkDataNodeSelection.h>
 
 // qt
 #include <QMessageBox>
 
 // namespace that contains the concrete action
 namespace RemoveFromSemanticRelationsAction
 {
   void Run(mitk::DataStorage* dataStorage, const mitk::DataNode* dataNode)
   {
     if (nullptr == dataStorage
      || nullptr == dataNode)
     {
       return;
     }
 
     if (mitk::NodePredicates::GetImagePredicate()->CheckNode(dataNode))
     {
       try
       {
         RemoveImage(dataStorage, dataNode);
       }
       catch (mitk::SemanticRelationException& e)
       {
         mitkReThrow(e);
       }
     }
     else if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
     {
       try
       {
         RemoveSegmentation(dataNode);
       }
       catch (mitk::SemanticRelationException& e)
       {
         mitkReThrow(e);
       }
     }
   }
 
   void RemoveImage(mitk::DataStorage* dataStorage, const mitk::DataNode* image)
   {
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
     try
     {
       // remove each corresponding segmentation from the semantic relations storage
       mitk::DataStorage::SetOfObjects::ConstPointer childNodes = dataStorage->GetDerivations(image, mitk::NodePredicates::GetSegmentationPredicate(), false);
       for (auto it = childNodes->Begin(); it != childNodes->End(); ++it)
       {
         RemoveSegmentation(it->Value());
       }
       // remove the image from the semantic relations storage
       semanticRelationsIntegration.RemoveImage(image);
     }
     catch (mitk::SemanticRelationException& e)
     {
       mitkReThrow(e);
     }
   }
 
   void RemoveSegmentation(const mitk::DataNode* segmentation)
   {
     mitk::SemanticRelationsIntegration semanticRelationsIntegration;
     try
     {
       // remove the segmentation from the semantic relations storage
       semanticRelationsIntegration.RemoveSegmentation(segmentation);
     }
     catch (mitk::SemanticRelationException& e)
     {
       mitkReThrow(e);
     }
   }
 }
 
 QmitkDataNodeRemoveFromSemanticRelationsAction::QmitkDataNodeRemoveFromSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchPartSite)
 {
   setText(tr("Remove from semantic relations"));
   InitializeAction();
 }
 
 QmitkDataNodeRemoveFromSemanticRelationsAction::QmitkDataNodeRemoveFromSemanticRelationsAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Remove from semantic relations"));
   InitializeAction();
 }
 
 void QmitkDataNodeRemoveFromSemanticRelationsAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkDataNodeRemoveFromSemanticRelationsAction::OnActionTriggered);
 }
 
 void QmitkDataNodeRemoveFromSemanticRelationsAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
   auto dataNode = GetSelectedNode();
-  RemoveFromSemanticRelationsAction::Run(m_DataStorage.Lock(),dataNode);
+  RemoveFromSemanticRelationsAction::Run(dataStorage, dataNode);
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.cpp
index 125503f0da..58a8521275 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetControlPointAction.cpp
@@ -1,170 +1,170 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations plugin
 #include "QmitkDataNodeSetControlPointAction.h"
 #include "QmitkDataNodeRemoveFromSemanticRelationsAction.h"
 
 // semantic relations module
 #include <mitkControlPointManager.h>
 #include <mitkDICOMHelper.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsDataStorageAccess.h>
 #include <mitkSemanticRelationsInference.h>
 #include <mitkSemanticRelationsIntegration.h>
 #include <mitkUIDGeneratorBoost.h>
 
 // semantic relations UI module
 #include "QmitkControlPointDialog.h"
 
 // qt
 #include <QInputDialog>
 #include <QMessageBox>
 
 QmitkDataNodeSetControlPointAction::QmitkDataNodeSetControlPointAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchPartSite)
 {
   setText(tr("Set control point"));
   m_Parent = parent;
   InitializeAction();
 }
 
 QmitkDataNodeSetControlPointAction::QmitkDataNodeSetControlPointAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Set control point"));
   m_Parent = parent;
   InitializeAction();
 }
 
 void QmitkDataNodeSetControlPointAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkDataNodeSetControlPointAction::OnActionTriggered);
 }
 
 void QmitkDataNodeSetControlPointAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
   QmitkControlPointDialog* inputDialog = new QmitkControlPointDialog(m_Parent);
   inputDialog->setWindowTitle("Set control point");
   inputDialog->SetCurrentDate(mitk::SemanticRelationsInference::GetControlPointOfImage(dataNode));
 
   int dialogReturnValue = inputDialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   const QDate& userSelectedDate = inputDialog->GetCurrentDate();
   mitk::SemanticTypes::ControlPoint controlPoint;
   controlPoint.UID = mitk::UIDGeneratorBoost::GenerateUID();
   controlPoint.date = boost::gregorian::date(userSelectedDate.year(),
                                              userSelectedDate.month(),
                                              userSelectedDate.day());
 
   mitk::SemanticTypes::InformationType informationType;
   mitk::SemanticTypes::ExaminationPeriod examinationPeriod;
   mitk::SemanticRelationsDataStorageAccess::DataNodeVector allSpecificImages;
   try
   {
     mitk::SemanticTypes::CaseID caseID = mitk::GetCaseIDFromDataNode(dataNode);
     informationType = mitk::SemanticRelationsInference::GetInformationTypeOfImage(dataNode);
     // see if the examination period - information type cell is already taken
     examinationPeriod = mitk::FindFittingExaminationPeriod(caseID, controlPoint);
     auto semanticRelationsDataStorageAccess = mitk::SemanticRelationsDataStorageAccess(dataStorage);
     try
     {
       allSpecificImages = semanticRelationsDataStorageAccess.GetAllSpecificImages(caseID, informationType, examinationPeriod);
     }
     catch (const mitk::SemanticRelationException&)
     {
       // just continue since an exception means that there is no specific image
     }
   }
   catch (const mitk::SemanticRelationException& e)
   {
     std::stringstream exceptionMessage; exceptionMessage << e;
     QMessageBox msgBox(QMessageBox::Warning,
       "Could not set the control point.",
       "The program wasn't able to correctly set the control point.\n"
       "Reason:\n" + QString::fromStdString(exceptionMessage.str() + "\n"));
     msgBox.exec();
   }
 
   if (!allSpecificImages.empty())
   {
     // examination period - information type cell is already taken
     // ask if cell should be overwritten
     QMessageBox::StandardButton answerButton =
       QMessageBox::question(nullptr,
         "Specific image already exists.",
         QString::fromStdString("Force overwriting existing image " + informationType + " at " + examinationPeriod.name + "?"),
         QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
     if (answerButton == QMessageBox::Yes)
     {
       try
       {
         // remove already existent images at specific cell
         for (const auto& specificImage : allSpecificImages)
         {
           RemoveFromSemanticRelationsAction::Run(dataStorage, specificImage);
         }
       }
       catch (const mitk::SemanticRelationException& e)
       {
         std::stringstream exceptionMessage; exceptionMessage << e;
         QMessageBox msgBox(QMessageBox::Warning,
           "Could not set the control point.",
           "The program wasn't able to correctly set the control point.\n"
           "Reason:\n" + QString::fromStdString(exceptionMessage.str() + "\n"));
         msgBox.exec();
       }
     }
     else
     {
       // else case is: no overwriting
       return;
     }
   }
 
   // specific image does not exist or has been removed; setting the control point should work
   mitk::SemanticRelationsIntegration semanticRelationsIntegration;
   try
   {
     semanticRelationsIntegration.UnlinkImageFromControlPoint(dataNode);
     semanticRelationsIntegration.SetControlPointOfImage(dataNode, controlPoint);
   }
   catch (const mitk::SemanticRelationException& e)
   {
     std::stringstream exceptionMessage; exceptionMessage << e;
     QMessageBox msgBox(QMessageBox::Warning,
       "Could not set the control point.",
       "The program wasn't able to correctly set the control point.\n"
       "Reason:\n" + QString::fromStdString(exceptionMessage.str() + "\n"));
     msgBox.exec();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.cpp
index 304758f658..079475afee 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataNodeSetInformationTypeAction.cpp
@@ -1,161 +1,161 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations plugin
 #include "QmitkDataNodeSetInformationTypeAction.h"
 #include "QmitkDataNodeRemoveFromSemanticRelationsAction.h"
 
 // semantic relations module
 #include <mitkControlPointManager.h>
 #include <mitkDICOMHelper.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsDataStorageAccess.h>
 #include <mitkSemanticRelationsInference.h>
 #include <mitkSemanticRelationsIntegration.h>
 
 // qt
 #include <QInputDialog>
 #include <QMessageBox>
 
 QmitkDataNodeSetInformationTypeAction::QmitkDataNodeSetInformationTypeAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchPartSite)
 {
   setText(tr("Set information type"));
   m_Parent = parent;
   InitializeAction();
 }
 
 QmitkDataNodeSetInformationTypeAction::QmitkDataNodeSetInformationTypeAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Set information type"));
   m_Parent = parent;
   InitializeAction();
 }
 
 void QmitkDataNodeSetInformationTypeAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkDataNodeSetInformationTypeAction::OnActionTriggered);
 }
 
 void QmitkDataNodeSetInformationTypeAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
   QInputDialog* inputDialog = new QInputDialog(m_Parent);
   inputDialog->setWindowTitle(tr("Set information type of selected node"));
   inputDialog->setLabelText(tr("Information type:"));
   inputDialog->setTextValue(QString::fromStdString(mitk::SemanticRelationsInference::GetInformationTypeOfImage(dataNode)));
   inputDialog->setMinimumSize(250, 100);
 
   int dialogReturnValue = inputDialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   mitk::SemanticTypes::InformationType informationType = inputDialog->textValue().toStdString();
 
   mitk::SemanticTypes::ExaminationPeriod examinationPeriod;
   mitk::SemanticTypes::ControlPoint controlPoint;
   mitk::SemanticRelationsDataStorageAccess::DataNodeVector allSpecificImages;
   try
   {
     mitk::SemanticTypes::CaseID caseID = mitk::GetCaseIDFromDataNode(dataNode);
     controlPoint = mitk::SemanticRelationsInference::GetControlPointOfImage(dataNode);
     // see if the examination period - information type cell is already taken
     examinationPeriod = mitk::FindFittingExaminationPeriod(caseID, controlPoint);
     auto semanticRelationsDataStorageAccess = mitk::SemanticRelationsDataStorageAccess(dataStorage);
     try
     {
       allSpecificImages = semanticRelationsDataStorageAccess.GetAllSpecificImages(caseID, informationType, examinationPeriod);
     }
     catch (const mitk::SemanticRelationException&)
     {
       // just continue since an exception means that there is no specific image
     }
   }
   catch (const mitk::SemanticRelationException& e)
   {
     std::stringstream exceptionMessage; exceptionMessage << e;
     QMessageBox msgBox(QMessageBox::Warning,
       "Could not set the information type.",
       "The program wasn't able to correctly set the information type.\n"
       "Reason:\n" + QString::fromStdString(exceptionMessage.str() + "\n"));
     msgBox.exec();
   }
 
   if (!allSpecificImages.empty())
   {
     // examination period - information type cell is already taken
     // ask if cell should be overwritten
     QMessageBox::StandardButton answerButton =
       QMessageBox::question(nullptr,
         "Specific image already exists.",
         QString::fromStdString("Force overwriting existing image " + informationType + " at " + examinationPeriod.name + "?"),
         QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
     if (answerButton == QMessageBox::Yes)
     {
       try
       {
         // remove already existent images at specific cell
         for (const auto& specificImage : allSpecificImages)
         {
           RemoveFromSemanticRelationsAction::Run(dataStorage, specificImage);
         }
       }
       catch (const mitk::SemanticRelationException& e)
       {
         std::stringstream exceptionMessage; exceptionMessage << e;
         QMessageBox msgBox(QMessageBox::Warning,
           "Could not set the information type.",
           "The program wasn't able to correctly set the information type.\n"
           "Reason:\n" + QString::fromStdString(exceptionMessage.str() + "\n"));
         msgBox.exec();
       }
     }
     else
     {
       // else case is: no overwriting
       return;
     }
   }
 
   mitk::SemanticRelationsIntegration semanticRelationsIntegration;
   try
   {
     semanticRelationsIntegration.SetInformationType(dataNode, informationType);
   }
   catch (const mitk::SemanticRelationException& e)
   {
     std::stringstream exceptionMessage; exceptionMessage << e;
     QMessageBox msgBox(QMessageBox::Warning,
       "Could not set the information type.",
       "The program wasn't able to correctly set the information type.\n"
       "Reason:\n" + QString::fromStdString(exceptionMessage.str() + "\n"));
     msgBox.exec();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataSetOpenInAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataSetOpenInAction.cpp
index 4447ba851d..3156db0e06 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataSetOpenInAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkDataSetOpenInAction.cpp
@@ -1,158 +1,160 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations plugin
 #include "QmitkDataSetOpenInAction.h"
 
 // mitk core
 #include <mitkImage.h>
 #include <mitkRenderingManager.h>
 
 // render window manager module
 #include <mitkRenderWindowLayerController.h>
 #include <mitkRenderWindowLayerUtilities.h>
 
 // semantic relations module
 #include "mitkNodePredicates.h"
 
 // mitk gui qt application plugin
 #include <QmitkDataNodeReinitAction.h>
 
 // qt
 #include <QMessageBox>
 #include <QMenu>
 
 namespace OpenInAction
 {
   void Run(mitk::DataStorage::Pointer dataStorage, mitk::DataNode::Pointer imageNode, mitk::BaseRenderer* renderer /*= nullptr*/)
   {
     if (dataStorage.IsNull())
     {
       return;
     }
 
     if (imageNode.IsNull())
     {
       return;
     }
 
     auto renderWindowLayerController = std::make_unique<mitk::RenderWindowLayerController>();
     renderWindowLayerController->SetDataStorage(dataStorage);
 
     // get currently fixed layer nodes of the specified renderer
     // remove them from the specified renderer
     auto layerStack = mitk::RenderWindowLayerUtilities::GetLayerStack(dataStorage, renderer, true);
     for (auto& fixedLayer : layerStack)
     {
       // hide all nodes of the specified renderer
       fixedLayer.second->SetVisibility(false, renderer);
       fixedLayer.second->Modified();
     }
 
     // add the selected data node to the specified renderer
     // only needed in case the render window manager plugin is not used
     imageNode->SetBoolProperty("fixedLayer", true, renderer);
     // make is visible
     imageNode->SetVisibility(true, renderer);
     imageNode->Modified();
     // move node to front, which also request a render update
     renderWindowLayerController->MoveNodeToFront(imageNode, renderer);
 
     QList<mitk::DataNode::Pointer> visibleNodes;
     visibleNodes.push_back(imageNode);
     // get all corresponding segmentations of this node
     mitk::DataStorage::SetOfObjects::ConstPointer segmentationNodes = dataStorage->GetDerivations(imageNode, mitk::NodePredicates::GetSegmentationPredicate(), false);
     for (auto it = segmentationNodes->Begin(); it != segmentationNodes->End(); ++it)
     {
       auto segmentation = it->Value();
       segmentation->SetBoolProperty("fixedLayer", true, renderer);
       segmentation->SetVisibility(true, renderer);
       // move node to front, which also request a render update
       renderWindowLayerController->MoveNodeToFront(segmentation, renderer);
       visibleNodes.push_back(segmentation);
     }
 
     ReinitAction::Run(berry::IWorkbenchPartSite::Pointer(), dataStorage, visibleNodes, renderer);
   }
 }
 
 QmitkDataSetOpenInAction::QmitkDataSetOpenInAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QmitkDataNodeOpenInAction(parent, workbenchPartSite)
 {
   setText(tr("Open in"));
   InitializeAction();
 }
 
 QmitkDataSetOpenInAction::QmitkDataSetOpenInAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QmitkDataNodeOpenInAction(parent, berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Open in"));
   InitializeAction();
 }
 
 void QmitkDataSetOpenInAction::InitializeAction()
 {
   setCheckable(true);
 
   setMenu(new QMenu);
   connect(menu(), &QMenu::aboutToShow, this, &QmitkDataSetOpenInAction::OnMenuAboutToShow);
 
   SetControlledRenderer();
 }
 
 void QmitkDataSetOpenInAction::OnMenuAboutToShow()
 {
   menu()->clear();
   QAction* action;
 
   QStringList rendererNames;
   for (const auto& renderer : m_ControlledRenderer)
   {
     rendererNames.append(renderer->GetName());
   }
 
   rendererNames.sort();
   for (const auto& rendererName : rendererNames)
   {
     action = menu()->addAction(rendererName);
     connect(action, &QAction::triggered, this, &QmitkDataSetOpenInAction::OnActionTriggered);
   }
 }
 
 void QmitkDataSetOpenInAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
   QAction* senderAction = qobject_cast<QAction*>(QObject::sender());
   if (nullptr == senderAction)
   {
     return;
   }
 
   std::string selectedRenderer = senderAction->text().toStdString();
   mitk::BaseRenderer* renderer = mitk::BaseRenderer::GetByName(selectedRenderer);
   if (nullptr == renderer)
   {
     return;
   }
 
-  OpenInAction::Run(m_DataStorage.Lock(), dataNode, renderer);
+  OpenInAction::Run(dataStorage, dataNode, renderer);
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkFocusOnLesionAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkFocusOnLesionAction.cpp
index 46d828e71d..d54629da0c 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkFocusOnLesionAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkFocusOnLesionAction.cpp
@@ -1,122 +1,125 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations plugin
 #include "QmitkFocusOnLesionAction.h"
 #include "QmitkLabelSetJumpToAction.h"
 
 // mitk core
 #include <mitkImage.h>
 #include <mitkRenderingManager.h>
 
 // render window manager module
 #include <mitkRenderWindowLayerController.h>
 #include <mitkRenderWindowLayerUtilities.h>
 
 // semantic relations module
 #include <mitkDICOMHelper.h>
 #include <mitkSemanticRelationsInference.h>
 
 // qt
 #include <QMessageBox>
 #include <QMenu>
 
 QmitkFocusOnLesionAction::QmitkFocusOnLesionAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchPartSite)
 {
   setText(tr("Focus on lesion"));
   InitializeAction();
 }
 
 QmitkFocusOnLesionAction::QmitkFocusOnLesionAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Focus on lesion"));
   InitializeAction();
 }
 
 void QmitkFocusOnLesionAction::SetSelectedLesion(mitk::SemanticTypes::Lesion selectedLesion)
 {
   m_Lesion = selectedLesion;
 }
 
 void QmitkFocusOnLesionAction::InitializeAction()
 {
   setCheckable(true);
   connect(this, &QAction::triggered, this, &QmitkFocusOnLesionAction::OnActionTriggered);
 
   SetControlledRenderer();
 }
 
 void QmitkFocusOnLesionAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_WorkbenchPartSite.Expired())
+  auto workbenchPartSite = m_WorkbenchPartSite.Lock();
+
+  if (workbenchPartSite.IsNull())
   {
     return;
   }
 
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
   auto renderWindowLayerController = std::make_unique<mitk::RenderWindowLayerController>();
   renderWindowLayerController->SetDataStorage(dataStorage);
   // check each renderer to see if it contains a segmentation represented by the currently selected lesion
   for (const auto& renderer : m_ControlledRenderer)
   {
     // get currently fixed layer nodes of the specified renderer
     auto layerStack = mitk::RenderWindowLayerUtilities::GetLayerStack(dataStorage, renderer, true);
     // check each node to see if it is a segmentation represented by the currently selected lesion
     for (const auto& layer : layerStack)
     {
       auto dataNode = layer.second;
       bool isVisible = false;
       if (dataNode.IsNotNull())
       {
         dataNode->GetBoolProperty("visible", isVisible, renderer);
       }
 
       // only focus in renderer where the segmentation is visible
       if (!isVisible)
       {
         continue;
       }
 
       auto currentLesion = mitk::SemanticRelationsInference::GetLesionOfSegmentation(dataNode);
       if (currentLesion.UID == m_Lesion.UID)
       {
         // jump to this lesion in the specified renderer
-        LabelSetJumpToAction::Run(m_WorkbenchPartSite.Lock(), dataNode, renderer);
+        LabelSetJumpToAction::Run(workbenchPartSite, dataNode, renderer);
       }
     }
   }
 }
 
 void QmitkFocusOnLesionAction::SetControlledRenderer()
 {
   const mitk::RenderingManager::RenderWindowVector allRegisteredRenderWindows =
     mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
   mitk::BaseRenderer *baseRenderer = nullptr;
   m_ControlledRenderer.clear();
   for (const auto& renderWindow : allRegisteredRenderWindows)
   {
     baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow);
     if (nullptr != baseRenderer)
     {
       m_ControlledRenderer.push_back(baseRenderer);
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLabelSetJumpToAction.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLabelSetJumpToAction.cpp
index 23cefceab6..3585dfc626 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLabelSetJumpToAction.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLabelSetJumpToAction.cpp
@@ -1,119 +1,121 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // mitk gui qt application plugin
 #include "QmitkLabelSetJumpToAction.h"
 
 // mitk core
 #include <mitkImage.h>
 #include <mitkRenderingManager.h>
 #include <mitkWorkbenchUtil.h>
 
 // mitk multi label module
 #include <mitkLabelSetImage.h>
 
 // qt
 #include <QMessageBox>
 #include <QMenu>
 
 namespace LabelSetJumpToAction
 {
   void Run(berry::IWorkbenchPartSite::Pointer workbenchPartSite, const mitk::DataNode* dataNode, mitk::BaseRenderer* baseRenderer /*= nullptr*/)
   {
     if (workbenchPartSite.IsNull())
     {
       return;
     }
 
     if (nullptr == dataNode)
     {
       return;
     }
 
     mitk::LabelSetImage* labelSetImage = dynamic_cast<mitk::LabelSetImage*>(dataNode->GetData());
     if (nullptr == labelSetImage)
     {
       return;
     }
 
     unsigned int activeLayer = labelSetImage->GetActiveLayer();
     mitk::Label* activeLabel = labelSetImage->GetActiveLabel(activeLayer);
     labelSetImage->UpdateCenterOfMass(activeLabel->GetValue(), activeLayer);
     const mitk::Point3D& centerPosition = activeLabel->GetCenterOfMassCoordinates();
     if (centerPosition.GetVnlVector().max_value() > 0.0)
     {
       auto renderWindowPart = mitk::WorkbenchUtil::GetRenderWindowPart(workbenchPartSite->GetPage(), mitk::WorkbenchUtil::NONE);
       if (nullptr == renderWindowPart)
       {
         renderWindowPart = mitk::WorkbenchUtil::OpenRenderWindowPart(workbenchPartSite->GetPage(), false);
         if (nullptr == renderWindowPart)
         {
           // no render window available
           return;
         }
       }
 
       auto segmentation = dynamic_cast<mitk::LabelSetImage*>(dataNode->GetData());
       if (nullptr != segmentation)
       {
         if (nullptr == baseRenderer)
         {
           renderWindowPart->SetSelectedPosition(centerPosition);
           mitk::RenderingManager::GetInstance()->InitializeViews(segmentation->GetTimeGeometry());
         }
         else
         {
           renderWindowPart->SetSelectedPosition(centerPosition, baseRenderer->GetName());
           mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), segmentation->GetTimeGeometry());
         }
       }
     }
   }
 }
 
 QmitkLabelSetJumpToAction::QmitkLabelSetJumpToAction(QWidget* parent, berry::IWorkbenchPartSite::Pointer workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(workbenchPartSite)
 {
   setText(tr("Jump to"));
   InitializeAction();
 }
 
 QmitkLabelSetJumpToAction::QmitkLabelSetJumpToAction(QWidget* parent, berry::IWorkbenchPartSite* workbenchPartSite)
   : QAction(parent)
   , QmitkAbstractDataNodeAction(berry::IWorkbenchPartSite::Pointer(workbenchPartSite))
 {
   setText(tr("Jump to"));
   InitializeAction();
 }
 
 void QmitkLabelSetJumpToAction::InitializeAction()
 {
   connect(this, &QAction::triggered, this, &QmitkLabelSetJumpToAction::OnActionTriggered);
 }
 
 void QmitkLabelSetJumpToAction::OnActionTriggered(bool /*checked*/)
 {
-  if (m_WorkbenchPartSite.Expired())
+  auto workbenchPartSite = m_WorkbenchPartSite.Lock();
+
+  if (workbenchPartSite.IsNull())
   {
     return;
   }
 
   auto dataNode = GetSelectedNode();
   if (dataNode.IsNull())
   {
     return;
   }
 
   mitk::BaseRenderer::Pointer baseRenderer = GetBaseRenderer();
-  LabelSetJumpToAction::Run(m_WorkbenchPartSite.Lock(), dataNode, baseRenderer);
+  LabelSetJumpToAction::Run(workbenchPartSite, dataNode, baseRenderer);
 }
diff --git a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.cpp b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.cpp
index c9e6cc8d40..4570a97efb 100644
--- a/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.semanticrelations/src/internal/QmitkLesionInfoWidget.cpp
@@ -1,492 +1,495 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // semantic relations plugin
 #include "QmitkLesionInfoWidget.h"
 #include "QmitkDataNodeAddToSemanticRelationsAction.h"
 #include "QmitkFocusOnLesionAction.h"
 #include "QmitkSemanticRelationsNodeSelectionDialog.h"
 
 // semantic relations UI module
 #include <QmitkLesionTextDialog.h>
 
 // semantic relations module
 #include <mitkLesionManager.h>
 #include <mitkNodePredicates.h>
 #include <mitkSemanticRelationException.h>
 #include <mitkSemanticRelationsInference.h>
 #include <mitkRelationStorage.h>
 
 // segmentation
 #include <mitkLabelSetImage.h>
 #include <QmitkNewSegmentationDialog.h>
 
 // qt
 #include <QCompleter>
 #include <QListWidget>
 #include <QMenu>
 #include <QMessageBox>
 #include <QString>
 
 QmitkLesionInfoWidget::QmitkLesionInfoWidget(mitk::DataStorage* dataStorage,
                                              berry::IWorkbenchPartSite::Pointer workbenchPartSite,
                                              QWidget* parent /*= nullptr*/)
   : QWidget(parent)
   , m_DataStorage(dataStorage)
   , m_WorkbenchPartSite(workbenchPartSite)
   , m_SemanticRelationsDataStorageAccess(std::make_unique<mitk::SemanticRelationsDataStorageAccess>(dataStorage))
   , m_SemanticRelationsIntegration(std::make_unique<mitk::SemanticRelationsIntegration>())
 {
   Initialize();
 }
 
 void QmitkLesionInfoWidget::Initialize()
 {
   m_Controls.setupUi(this);
 
   m_Controls.lesionTreeView->setAlternatingRowColors(true);
   m_Controls.lesionTreeView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.lesionTreeView->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_Controls.lesionTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   m_StorageModel = new QmitkLesionTreeModel(m_Controls.lesionTreeView);
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
   m_StorageModel->SetDataStorage(dataStorage);
   m_Controls.lesionTreeView->setModel(m_StorageModel);
 
   SetUpConnections();
 }
 
 void QmitkLesionInfoWidget::SetUpConnections()
 {
   connect(m_StorageModel, &QmitkLesionTreeModel::ModelUpdated, this, &QmitkLesionInfoWidget::OnModelUpdated);
   connect(m_Controls.addLesionPushButton, &QPushButton::clicked, this, &QmitkLesionInfoWidget::OnAddLesionButtonClicked);
   connect(m_Controls.lesionTreeView->selectionModel(), &QItemSelectionModel::currentChanged, this, &QmitkLesionInfoWidget::OnSelectionChanged);
   connect(m_Controls.lesionTreeView, &QTreeView::customContextMenuRequested, this, &QmitkLesionInfoWidget::OnLesionListContextMenuRequested);
 }
 
 void QmitkLesionInfoWidget::SetCaseID(const mitk::SemanticTypes::CaseID& caseID)
 {
   m_CaseID = caseID;
   m_StorageModel->SetCaseID(caseID);
 }
 
 void QmitkLesionInfoWidget::SetDataNodeSelection(const QList<mitk::DataNode::Pointer>& dataNodeSelection)
 {
   m_StorageModel->SetDataNodeSelection(dataNodeSelection);
 }
 
 //////////////////////////////////////////////////////////////////////////
 // Implementation of the QT_SLOTS
 //////////////////////////////////////////////////////////////////////////
 void QmitkLesionInfoWidget::OnModelUpdated()
 {
   m_Controls.lesionTreeView->expandAll();
   int columns = m_Controls.lesionTreeView->model()->columnCount();
   for (int i = 0; i < columns; ++i)
   {
     m_Controls.lesionTreeView->resizeColumnToContents(i);
   }
 }
 
 void QmitkLesionInfoWidget::OnAddLesionButtonClicked()
 {
   if (m_CaseID.empty())
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No case ID set.",
       "In order to add a lesion, please specify the current case / patient.");
     msgBox.exec();
     return;
   }
 
   mitk::SemanticTypes::Lesion newLesion = mitk::GenerateNewLesion();
   try
   {
     m_SemanticRelationsIntegration->AddLesion(m_CaseID, newLesion);
   }
   catch (mitk::SemanticRelationException& e)
   {
     MITK_INFO << "Could not add a new lesion. " << e;
   }
 }
 
 void QmitkLesionInfoWidget::OnSelectionChanged(const QModelIndex& current, const QModelIndex& /*previous*/)
 {
   // only the UID is needed to identify a representing lesion
   QVariant data = m_StorageModel->data(current, Qt::UserRole);
   if (!data.canConvert<QmitkLesionTreeItem*>())
   {
     return;
   }
 
   auto lesion = data.value<QmitkLesionTreeItem*>()->GetData().GetLesion();
   if (false == mitk::SemanticRelationsInference::InstanceExists(m_CaseID, lesion))
   {
     // no UID of a existing lesion found; cannot create a lesion
     return;
   }
 
   // if selected data nodes are set, reset to empty list to
   // hide "selected data nodes presence background highlighting" in the model
   if (!m_StorageModel->GetSelectedDataNodes().isEmpty())
   {
     m_StorageModel->SetDataNodeSelection(QList<mitk::DataNode::Pointer>());
   }
 
   emit LesionSelectionChanged(lesion);
 }
 
 void QmitkLesionInfoWidget::OnLesionListContextMenuRequested(const QPoint& pos)
 {
   if (nullptr == m_SemanticRelationsIntegration)
   {
     return;
   }
 
   if (m_CaseID.empty())
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No case ID set.",
       "In order to access the context menu entries a case ID has to be set.");
     msgBox.exec();
     return;
   }
 
   QModelIndex index = m_Controls.lesionTreeView->indexAt(pos);
   if (!index.isValid())
   {
     // no item clicked; cannot retrieve the current lesion
     return;
   }
 
   QVariant data = m_StorageModel->data(index, Qt::UserRole);
   mitk::SemanticTypes::Lesion selectedLesion;
   if (data.canConvert<QmitkLesionTreeItem*>())
   {
     selectedLesion = data.value<QmitkLesionTreeItem*>()->GetData().GetLesion();
   }
   else
   {
     return;
   }
 
   QMenu* menu = new QMenu(m_Controls.lesionTreeView);
 
   QAction* linkToSegmentation = new QAction("Link to segmentation", this);
   linkToSegmentation->setEnabled(true);
   connect(linkToSegmentation, &QAction::triggered, [this, selectedLesion] { OnLinkToSegmentation(selectedLesion); });
   menu->addAction(linkToSegmentation);
 
   QAction* setLesionName = new QAction("Set lesion name", this);
   setLesionName->setEnabled(true);
   connect(setLesionName, &QAction::triggered, [this, selectedLesion] { OnSetLesionName(selectedLesion); });
   menu->addAction(setLesionName);
 
   QAction* setLesionClass = new QAction("Set lesion class", this);
   setLesionClass->setEnabled(true);
   connect(setLesionClass, &QAction::triggered, [this, selectedLesion] { OnSetLesionClass(selectedLesion); });
   menu->addAction(setLesionClass);
 
   QAction* createNewSegmentation = new QAction("Create new lesion", this);
   createNewSegmentation->setEnabled(true);
   connect(createNewSegmentation, &QAction::triggered, [this, selectedLesion] { OnCreateNewSegmentation(selectedLesion); });
   menu->addAction(createNewSegmentation);
 
   QAction* removeLesion = new QAction("Remove lesion", this);
   removeLesion->setEnabled(true);
   connect(removeLesion, &QAction::triggered, [this, selectedLesion] { OnRemoveLesion(selectedLesion); });
   menu->addAction(removeLesion);
 
-  if (!m_WorkbenchPartSite.Expired())
+  auto workbenchPartSite = m_WorkbenchPartSite.Lock();
+
+  if (workbenchPartSite.IsNotNull())
   {
-    QmitkFocusOnLesionAction* focusOnLesion = new QmitkFocusOnLesionAction(this, m_WorkbenchPartSite.Lock());
+    QmitkFocusOnLesionAction* focusOnLesion = new QmitkFocusOnLesionAction(this, workbenchPartSite);
     focusOnLesion->SetDataStorage(m_DataStorage.Lock());
     focusOnLesion->SetSelectedLesion(selectedLesion);
     menu->addAction(focusOnLesion);
   }
 
   menu->popup(QCursor::pos());
 }
 
 void QmitkLesionInfoWidget::OnLinkToSegmentation(mitk::SemanticTypes::Lesion selectedLesion)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   QmitkSemanticRelationsNodeSelectionDialog* dialog = new QmitkSemanticRelationsNodeSelectionDialog(this, "Select segmentation to link to the selected lesion.", "");
   dialog->setWindowTitle("Select segmentation node");
   dialog->SetDataStorage(dataStorage);
   dialog->SetNodePredicate(mitk::NodePredicates::GetSegmentationPredicate());
   dialog->SetSelectOnlyVisibleNodes(true);
   dialog->SetCaseID(m_CaseID);
   // set the last added segmentation node as pre-selected data node
   const mitk::DataNode* lastSegmentation = m_StorageModel->GetLastSegmentation();
   QList<mitk::DataNode::Pointer> selectedDataNodes;
   if (nullptr != lastSegmentation)
   {
     selectedDataNodes.push_back(const_cast<mitk::DataNode*>(lastSegmentation));
     dialog->SetCurrentSelection(selectedDataNodes);
   }
 
   int dialogReturnValue = dialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   mitk::DataNode::Pointer selectedDataNode = nullptr;
   selectedDataNodes = dialog->GetSelectedNodes();
   if (!selectedDataNodes.isEmpty())
   {
     // only single selection allowed
     selectedDataNode = selectedDataNodes.front();
   }
 
   if (nullptr == selectedDataNode
     || false == mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(selectedDataNode))
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No valid segmentation node selected.",
       "In order to link the selected lesion to a segmentation, please specify a valid segmentation node.");
     msgBox.exec();
     return;
   }
 
   mitk::BaseData* baseData = selectedDataNode->GetData();
   if (nullptr == baseData)
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No valid base data.",
       "In order to link the selected lesion to a segmentation, please specify a valid segmentation node.");
     msgBox.exec();
     return;
   }
 
   LinkSegmentationToLesion(selectedDataNode, selectedLesion);
 }
 
 void QmitkLesionInfoWidget::OnSetLesionName(mitk::SemanticTypes::Lesion selectedLesion)
 {
   // use the lesion information to set the input text for the dialog
   QmitkLesionTextDialog* inputDialog = new QmitkLesionTextDialog(this);
   inputDialog->setWindowTitle("Set lesion name");
   inputDialog->SetLineEditText(selectedLesion.name);
 
   int dialogReturnValue = inputDialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   selectedLesion.name = inputDialog->GetLineEditText().toStdString();
   m_SemanticRelationsIntegration->OverwriteLesion(m_CaseID, selectedLesion);
 }
 
 void QmitkLesionInfoWidget::OnSetLesionClass(mitk::SemanticTypes::Lesion selectedLesion)
 {
   // use the lesion information to set the input text for the dialog
   QmitkLesionTextDialog* inputDialog = new QmitkLesionTextDialog(this);
   inputDialog->setWindowTitle("Set lesion class");
   inputDialog->SetLineEditText(selectedLesion.lesionClass.classType);
 
   // prepare the completer for the dialogs input text field
   mitk::LesionClassVector allLesionClasses = mitk::SemanticRelationsInference::GetAllLesionClassesOfCase(m_CaseID);
 
   QStringList wordList;
   for (const auto& lesionClass : allLesionClasses)
   {
     wordList << QString::fromStdString(lesionClass.classType);
   }
   QCompleter* completer = new QCompleter(wordList, this);
   completer->setCaseSensitivity(Qt::CaseInsensitive);
   inputDialog->GetLineEdit()->setCompleter(completer);
 
   int dialogReturnValue = inputDialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   // retrieve the new input lesion class type and check for an already existing lesion class types
   std::string newLesionClassType = inputDialog->GetLineEditText().toStdString();
   mitk::SemanticTypes::LesionClass existingLesionClass = mitk::FindExistingLesionClass(m_CaseID, newLesionClassType);
   if (existingLesionClass.UID.empty())
   {
     // could not find lesion class information for the new lesion class type
     // create a new lesion class for the selected lesion
     existingLesionClass = mitk::GenerateNewLesionClass(newLesionClassType);
   }
 
   selectedLesion.lesionClass = existingLesionClass;
   m_SemanticRelationsIntegration->OverwriteLesion(m_CaseID, selectedLesion);
 }
 
 void QmitkLesionInfoWidget::OnCreateNewSegmentation(mitk::SemanticTypes::Lesion selectedLesion)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   QmitkSemanticRelationsNodeSelectionDialog* dialog = new QmitkSemanticRelationsNodeSelectionDialog(this, "Select image to segment lesion on.", "");
   dialog->setWindowTitle("Select image node");
   dialog->SetDataStorage(dataStorage);
   dialog->SetNodePredicate(mitk::NodePredicates::GetImagePredicate());
   dialog->SetSelectOnlyVisibleNodes(true);
   dialog->SetCaseID(m_CaseID);
   dialog->SetLesion(selectedLesion);
 
   int dialogReturnValue = dialog->exec();
   if (QDialog::Rejected == dialogReturnValue)
   {
     return;
   }
 
   auto nodes = dialog->GetSelectedNodes();
   mitk::DataNode::Pointer selectedDataNode = nullptr;
   if (!nodes.isEmpty())
   {
     // only single selection allowed
     selectedDataNode = nodes.front();
   }
 
   if (nullptr == selectedDataNode
     || false == mitk::NodePredicates::GetImagePredicate()->CheckNode(selectedDataNode))
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No valid image node selected.",
       "In order to create a new segmentation, please specify a valid image node.");
     msgBox.exec();
     return;
   }
 
   mitk::Image* selectedImage = dynamic_cast<mitk::Image*>(selectedDataNode->GetData());
   if (nullptr == selectedImage)
   {
     QMessageBox msgBox(QMessageBox::Warning,
       "No valid image.",
       "In order to create a new segmentation, please specify a valid image node.");
     msgBox.exec();
     return;
   }
 
   mitk::LabelSetImage::Pointer segmentation = mitk::LabelSetImage::New();
   try
   {
     segmentation->Initialize(selectedImage);
   }
   catch (mitk::Exception& e)
   {
     std::stringstream exceptionMessage; exceptionMessage << e;
     QMessageBox msgBox(QMessageBox::Warning,
       "Could not initialize segmentation.",
       "The segmentation could not be correctly initialized with the selected image geometry.\n"
       "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
     msgBox.exec();
     return;
   }
 
   auto segmentationDialog = new QmitkNewSegmentationDialog(this);
   segmentationDialog->setWindowTitle("New lesion segmentation");
 
   dialogReturnValue = segmentationDialog->exec();
   if (dialogReturnValue == QDialog::Rejected)
   {
     return;
   }
 
-  QString segmentatioName = segmentationDialog->GetSegmentationName();
+  QString segmentatioName = segmentationDialog->GetName();
   if (segmentatioName.isEmpty())
   {
     segmentatioName = "Unnamed";
   }
   segmentation->GetActiveLabelSet()->AddLabel(segmentatioName.toStdString(), segmentationDialog->GetColor());
 
   mitk::DataNode::Pointer segmentationNode = mitk::DataNode::New();
   segmentationNode->SetData(segmentation);
   segmentationNode->SetName(segmentatioName.toStdString());
   dataStorage->Add(segmentationNode, selectedDataNode);
 
   LinkSegmentationToLesion(segmentationNode, selectedLesion);
 }
 
 void QmitkLesionInfoWidget::OnRemoveLesion(mitk::SemanticTypes::Lesion selectedLesion)
 {
   try
   {
     m_SemanticRelationsIntegration->RemoveLesion(m_CaseID, selectedLesion);
   }
   catch (const mitk::SemanticRelationException& e)
   {
     std::stringstream exceptionMessage; exceptionMessage << e;
     QMessageBox msgBox(QMessageBox::Warning,
       "Could not remove the selected lesion.",
       "The program wasn't able to correctly remove the selected lesion from the semantic relations model.\n"
       "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
     msgBox.exec();
   }
 }
 
 void QmitkLesionInfoWidget::LinkSegmentationToLesion(const mitk::DataNode* selectedDataNode, mitk::SemanticTypes::Lesion selectedLesion)
 {
-  if (m_DataStorage.IsExpired())
+  auto dataStorage = m_DataStorage.Lock();
+
+  if (dataStorage.IsNull())
   {
     return;
   }
 
-  auto dataStorage = m_DataStorage.Lock();
-
   // if the segmentation is not contained in the semantic relations, add it
   if (!mitk::SemanticRelationsInference::InstanceExists(selectedDataNode))
   {
     try
     {
       AddToSemanticRelationsAction::Run(dataStorage, selectedDataNode);
     }
     catch (const mitk::SemanticRelationException& e)
     {
       std::stringstream exceptionMessage; exceptionMessage << e;
       QMessageBox msgBox(QMessageBox::Warning,
         "Could not link the selected lesion.",
         "The program wasn't able to correctly link the selected lesion with the selected segmentation.\n"
         "Reason:\n" + QString::fromStdString(exceptionMessage.str() + "\n"));
       msgBox.exec();
     }
   }
 
   // link the segmentation
   try
   {
     m_SemanticRelationsIntegration->LinkSegmentationToLesion(selectedDataNode, selectedLesion);
   }
   catch (const mitk::SemanticRelationException& e)
   {
     std::stringstream exceptionMessage; exceptionMessage << e;
     QMessageBox msgBox(QMessageBox::Warning,
       "Could not link the selected lesion.",
       "The program wasn't able to correctly link the selected lesion with the selected segmentation.\n"
       "Reason:\n" + QString::fromStdString(exceptionMessage.str()));
     msgBox.exec();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
index 53e1d71327..0c63ce567f 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,536 +1,536 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // Blueberry
 #include <mitkIRenderWindowPart.h>
 #include <mitkILinkedRenderWindowPart.h>
 
 // Qmitk
 #include "QmitkToFUtilView.h"
 
 // Qt
 #include <QMessageBox>
 #include <QString>
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <qcombobox.h>
 
 // MITK
 #include <mitkBaseRenderer.h>
 #include <mitkToFDistanceImageToPointSetFilter.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkToFDeviceFactoryManager.h>
 #include <mitkToFCameraDevice.h>
 #include <mitkCameraIntrinsicsProperty.h>
 #include <mitkSmartPointerProperty.h>
 #include <mitkRenderingModeProperty.h>
 #include <mitkVtkScalarModeProperty.h>
 
 // VTK
 #include <vtkCamera.h>
 #include <vtkPointData.h>
 #include <vtkPolyData.h>
 
 // ITK
 #include <itkCommand.h>
 #include <itksys/SystemTools.hxx>
 
 const std::string QmitkToFUtilView::VIEW_ID = "org.mitk.views.tofutil";
 
 //Constructor
 QmitkToFUtilView::QmitkToFUtilView()
   : QmitkAbstractView()
   , m_Controls(nullptr)
   , m_Framerateoutput(false)
   , m_MitkDistanceImage(nullptr), m_MitkAmplitudeImage(nullptr), m_MitkIntensityImage(nullptr), m_Surface(nullptr)
   , m_DistanceImageNode(nullptr), m_AmplitudeImageNode(nullptr), m_IntensityImageNode(nullptr), m_RGBImageNode(nullptr), m_SurfaceNode(nullptr)
   , m_ToFImageRecorder(nullptr), m_ToFImageGrabber(nullptr), m_ToFDistanceImageToSurfaceFilter(nullptr), m_ToFCompositeFilter(nullptr)
   , m_2DDisplayCount(0)
   , m_RealTimeClock(nullptr)
   , m_StepsForFramerate(100)
   , m_2DTimeBefore(0.0)
   , m_2DTimeAfter(0.0)
   , m_CameraIntrinsics(nullptr)
 {
   this->m_Frametimer = new QTimer(this);
 
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
 }
 
 //Destructor, specifically calling OnToFCameraStopped() and OnToFCammeraDiconnected()
 QmitkToFUtilView::~QmitkToFUtilView()
 {
   OnToFCameraStopped();
   OnToFCameraDisconnected();
 }
 
 //Createing the PartControl Signal-Slot principal
 void QmitkToFUtilView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkToFUtilViewControls;
     m_Controls->setupUi( parent );
 
     //Looking for Input and Defining reaction
     connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
 
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(KinectAcquisitionModeChanged()), this, SLOT(OnKinectAcquisitionModeChanged()) ); // Todo in Widget2
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraConnected()), this, SLOT(OnToFCameraConnected()) );
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraDisconnected()), this, SLOT(OnToFCameraDisconnected()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStarted()), this, SLOT(OnToFCameraStarted()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStopped()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStarted()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStopped()), this, SLOT(OnToFCameraStarted()) );
 }
 }
 
 //SetFocus-Method -> actually seting Focus to the Recorder
 void QmitkToFUtilView::SetFocus()
 {
   m_Controls->m_ToFRecorderWidget->setFocus();
 }
 
 //Activated-Method->Generating RenderWindow
 void QmitkToFUtilView::Activated()
 {
   //get the current RenderWindowPart or open a new one if there is none
   auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
   if (nullptr != renderWindowPart)
   {
     auto* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(renderWindowPart);
     if (linkedRenderWindowPart == nullptr)
     {
       MITK_ERROR << "No linked render window part avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(false);
     }
     renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOn();
     renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOn();
     renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOn();
 
     mitk::RenderingManager::GetInstance()->InitializeViews();
 
     this->UseToFVisibilitySettings(true);
 
     if (this->m_ToFCompositeFilter)
     {
       m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
     }
     if (this->GetDataStorage())
     {
       m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
     }
 
     if (this->m_ToFImageGrabber.IsNull())
     {
       m_Controls->m_ToFRecorderWidget->setEnabled(false);
       m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
       m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
       m_Controls->m_ToFMeasurementWidget->setEnabled(false);
       m_Controls->m_ToFSurfaceGenerationWidget->setEnabled(false);
     }
   }
 }
 
 //ZomnnieView-Method -> Resetting GUI to default. Why not just QmitkToFUtilView()?!
 void QmitkToFUtilView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer /*zombieView*/)
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::Deactivated()
 {
 }
 
 void QmitkToFUtilView::Visible()
 {
 }
 
 //Reset of the ToFUtilView
 void QmitkToFUtilView::Hidden()
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::OnToFCameraConnected()
 {
   MITK_DEBUG <<"OnToFCameraConnected";
   this->m_2DDisplayCount = 0;
 
   this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
 
   // initialize surface generation
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
 
   // initialize ToFImageRecorder and ToFRecorderWidget
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
   this->m_ToFImageRecorder->SetCameraDevice(this->m_ToFImageGrabber->GetCameraDevice());
   m_Controls->m_ToFRecorderWidget->SetParameter(this->m_ToFImageGrabber, this->m_ToFImageRecorder);
   m_Controls->m_ToFRecorderWidget->setEnabled(true);
   m_Controls->m_ToFRecorderWidget->ResetGUIToInitial();
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
 
   // initialize ToFCompositeFilterWidget
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   if (this->m_ToFCompositeFilter)
   {
     m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
   }
   if (this->GetDataStorage())
   {
     m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
   }
 
   if ( this->GetRenderWindowPart() )
     // initialize measurement widget
     m_Controls->m_ToFMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage(), this->m_ToFDistanceImageToSurfaceFilter->GetCameraIntrinsics());
   else
     MITK_WARN << "No render window part available!!! MeasurementWidget will not work.";
 
   this->m_RealTimeClock = mitk::RealTimeClock::New();
   this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkToFUtilView::ResetGUIToDefault()
 {
   auto* renderWindowPart = this->GetRenderWindowPart();
   if(nullptr != renderWindowPart)
   {
     auto* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(renderWindowPart);
     if(linkedRenderWindowPart == nullptr)
     {
       MITK_ERROR << "No linked render window part avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(true);
     }
     renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOff();
     renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
     renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOff();
-    renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
+    renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Coronal);
     renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOff();
 
     this->UseToFVisibilitySettings(false);
 
     //global reinit
     mitk::RenderingManager::GetInstance()->InitializeViews();
     this->RequestRenderWindowUpdate();
   }
 }
 
 void QmitkToFUtilView::OnToFCameraDisconnected()
 {
   this->GetDataStorage()->Remove(m_DistanceImageNode);
   if(m_RGBImageNode)
     this->GetDataStorage()->Remove(m_RGBImageNode);
   if(m_AmplitudeImageNode)
     this->GetDataStorage()->Remove(m_AmplitudeImageNode);
   if(m_IntensityImageNode)
     this->GetDataStorage()->Remove(m_IntensityImageNode);
   if(m_SurfaceNode)
     this->GetDataStorage()->Remove(m_SurfaceNode);
 
   m_Controls->m_ToFRecorderWidget->OnStop();
   m_Controls->m_ToFRecorderWidget->setEnabled(false);
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->m_ToFMeasurementWidget->setEnabled(false);
   m_Controls->m_ToFSurfaceGenerationWidget->setEnabled(false);
   //clean up measurement widget
   m_Controls->m_ToFMeasurementWidget->CleanUpWidget();
 }
 
 void QmitkToFUtilView::OnKinectAcquisitionModeChanged()
 {
   if (m_ToFCompositeFilter.IsNotNull()&&m_ToFImageGrabber.IsNotNull())
   {
     if (m_SelectedCamera.contains("Kinect"))
     {
       if (m_ToFImageGrabber->GetBoolProperty("RGB"))
       {
         this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
         this->m_ToFDistanceImageToSurfaceFilter->SetInput(3,this->m_ToFImageGrabber->GetOutput(3));
       }
       else if (m_ToFImageGrabber->GetBoolProperty("IR"))
       {
         this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
         this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
       }
     }
     this->UseToFVisibilitySettings(true);
   }
 }
 
 void QmitkToFUtilView::OnToFCameraStarted()
 {
   if (m_ToFImageGrabber.IsNotNull())
   {
     // initialize camera intrinsics
     if (this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))
     {
       m_CameraIntrinsics = dynamic_cast<mitk::CameraIntrinsicsProperty*>(this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))->GetValue();
       MITK_INFO << m_CameraIntrinsics->ToString();
     }
     else
     {
       m_CameraIntrinsics = nullptr;
       MITK_ERROR << "No camera intrinsics were found!";
     }
 
     // set camera intrinsics
     if ( m_CameraIntrinsics.IsNotNull() )
     {
       this->m_ToFDistanceImageToSurfaceFilter->SetCameraIntrinsics(m_CameraIntrinsics);
     }
 
     // initial update of image grabber
     this->m_ToFImageGrabber->Update();
 
     bool hasRGBImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasRGBImage",hasRGBImage);
 
     bool hasIntensityImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasIntensityImage",hasIntensityImage);
 
     bool hasAmplitudeImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasAmplitudeImage",hasAmplitudeImage);
 
     this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
     if(hasAmplitudeImage)
       this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
     if(hasIntensityImage)
       this->m_ToFCompositeFilter->SetInput(2,this->m_ToFImageGrabber->GetOutput(2));
 
     // initial update of composite filter
     this->m_ToFCompositeFilter->Update();
     this->m_MitkDistanceImage = m_ToFCompositeFilter->GetOutput();
     this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
 
     std::string rgbFileName;
     m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
 
     if(hasRGBImage || (rgbFileName!=""))
     {
       if(m_ToFImageGrabber->GetBoolProperty("IR"))
       {
         this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
       }
       else
       {
         this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
       }
     }
     else
     {
       this->m_RGBImageNode = nullptr;
     }
 
     if(hasAmplitudeImage)
     {
       this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
       this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
     }
 
     if(hasIntensityImage)
     {
       this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
       this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
     }
 
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(0,m_MitkDistanceImage);
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(1,m_MitkAmplitudeImage);
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(2,m_MitkIntensityImage);
 
     this->UseToFVisibilitySettings(true);
 
     this->m_SurfaceNode = ReplaceNodeData("Surface", nullptr);
     m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
     // initialize visualization widget
     m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode,
                                                              this->m_AmplitudeImageNode,
                                                              this->m_IntensityImageNode,
                                                              this->m_SurfaceNode);
     m_Controls->m_ToFSurfaceGenerationWidget->Initialize(m_ToFDistanceImageToSurfaceFilter,
                                                          m_ToFImageGrabber,
                                                          m_CameraIntrinsics,
                                                          m_SurfaceNode,
                                                          GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer()->GetActiveCamera());
     // set distance image to measurement widget
     m_Controls->m_ToFMeasurementWidget->SetDistanceImage(m_MitkDistanceImage);
 
     this->m_Frametimer->start(50);
 
     m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
     m_Controls->m_ToFCompositeFilterWidget->setEnabled(true);
     m_Controls->m_ToFMeasurementWidget->setEnabled(true);
     m_Controls->m_ToFSurfaceGenerationWidget->setEnabled(true);
   }
 }
 
 void QmitkToFUtilView::OnToFCameraStopped()
 {
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
 
   this->m_Frametimer->stop();
 }
 
 void QmitkToFUtilView::OnUpdateCamera()
 {
   if(!m_Controls->m_ToFSurfaceGenerationWidget->UpdateSurface())
   {
     // update pipeline
     this->m_MitkDistanceImage->Update();
   }
 
   this->RequestRenderWindowUpdate();
 
   if (m_Framerateoutput)
   {
     this->m_2DDisplayCount++;
     if ((this->m_2DDisplayCount % this->m_StepsForFramerate) == 0)
     {
       this->m_2DTimeAfter = this->m_RealTimeClock->GetCurrentStamp() - this->m_2DTimeBefore;
       MITK_INFO << " 2D-Display-framerate (fps): " << this->m_StepsForFramerate / (this->m_2DTimeAfter / 1000);
       this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
     }
   }
 
 }
 
 void QmitkToFUtilView::OnChangeCoronalWindowOutput(int index)
 {
   this->OnToFCameraStopped();
   if(index == 0)
   {
     if(this->m_IntensityImageNode.IsNotNull())
       this->m_IntensityImageNode->SetVisibility(false);
     if(this->m_RGBImageNode.IsNotNull())
       this->m_RGBImageNode->SetVisibility(true);
   }
   else if(index == 1)
   {
     if(this->m_IntensityImageNode.IsNotNull())
       this->m_IntensityImageNode->SetVisibility(true);
     if(this->m_RGBImageNode.IsNotNull())
       this->m_RGBImageNode->SetVisibility(false);
   }
   this->RequestRenderWindowUpdate();
   this->OnToFCameraStarted();
 }
 
 mitk::DataNode::Pointer QmitkToFUtilView::ReplaceNodeData( std::string nodeName, mitk::BaseData* data )
 {
   mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(nodeName);
   if (node.IsNull())
   {
     node = mitk::DataNode::New();
     node->SetName(nodeName);
     node->SetBoolProperty("binary",false);
     node->SetData(data);
     this->GetDataStorage()->Add(node);
   }
   else
   {
     node->SetData(data);
   }
   return node;
 }
 
 void QmitkToFUtilView::UseToFVisibilitySettings(bool useToF)
 {
   //We need this property for every node.
   auto renderingModePropertyForTransferFunction = mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
 
   auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
 
   auto* axialRenderer = mitk::BaseRenderer::GetInstance(renderWindowPart->GetQmitkRenderWindow("axial")->renderWindow());
   auto* sagittalRenderer = mitk::BaseRenderer::GetInstance(renderWindowPart->GetQmitkRenderWindow("sagittal")->renderWindow());
   auto* coronalRenderer = mitk::BaseRenderer::GetInstance(renderWindowPart->GetQmitkRenderWindow("coronal")->renderWindow());
   auto* threeDimRenderer = mitk::BaseRenderer::GetInstance(renderWindowPart->GetQmitkRenderWindow("3d")->renderWindow());
 
   // set node properties
   if (m_DistanceImageNode.IsNotNull())
   {
     this->m_DistanceImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     this->m_DistanceImageNode->SetVisibility( !useToF, sagittalRenderer );
     this->m_DistanceImageNode->SetVisibility( !useToF, coronalRenderer );
     this->m_DistanceImageNode->SetVisibility( !useToF, threeDimRenderer );
     this->m_DistanceImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if (m_AmplitudeImageNode.IsNotNull())
   {
     this->m_AmplitudeImageNode->SetVisibility( !useToF, axialRenderer );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, coronalRenderer );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, threeDimRenderer );
     this->m_AmplitudeImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if (m_IntensityImageNode.IsNotNull())
   {
       this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
       this->m_IntensityImageNode->SetVisibility( !useToF, axialRenderer );
       this->m_IntensityImageNode->SetVisibility( !useToF, sagittalRenderer );
       this->m_IntensityImageNode->SetVisibility( !useToF, threeDimRenderer );
       this->m_IntensityImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if ((m_RGBImageNode.IsNotNull()))
   {
       this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
       this->m_RGBImageNode->SetVisibility( !useToF, axialRenderer );
       this->m_RGBImageNode->SetVisibility( !useToF, sagittalRenderer );
       this->m_RGBImageNode->SetVisibility( !useToF, threeDimRenderer );
   }
   // initialize images
   if (m_MitkDistanceImage.IsNotNull())
   {
     mitk::RenderingManager::GetInstance()->InitializeViews(
       this->m_MitkDistanceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
   }
   if(this->m_SurfaceNode.IsNotNull())
   {
     QHash<QString, QmitkRenderWindow*> renderWindowHashMap = renderWindowPart->GetQmitkRenderWindows();
     QHashIterator<QString, QmitkRenderWindow*> i(renderWindowHashMap);
     while (i.hasNext()){
       i.next();
       this->m_SurfaceNode->SetVisibility( false, mitk::BaseRenderer::GetInstance(i.value()->renderWindow()) );
     }
     this->m_SurfaceNode->SetVisibility( true, mitk::BaseRenderer::GetInstance(renderWindowPart->GetQmitkRenderWindow("3d")->renderWindow() ) );
   }
   //disable/enable gradient background
   renderWindowPart->EnableDecorations(!useToF, QStringList(QString("background")));
 
   if((this->m_RGBImageNode.IsNotNull()))
   {
     bool RGBImageHasDifferentResolution = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("RGBImageHasDifferentResolution",RGBImageHasDifferentResolution);
     if(RGBImageHasDifferentResolution)
     {
       //update the display geometry by using the RBG image node. Only for renderwindow coronal
       mitk::RenderingManager::GetInstance()->InitializeView(renderWindowPart->GetQmitkRenderWindow("coronal")->renderWindow(),
         this->m_RGBImageNode->GetData()->GetGeometry());
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
index b4e5ff02af..0170559e19 100755
--- a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
@@ -1,239 +1,243 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkVolumeVisualizationView.h"
 
 #include <vtkSmartVolumeMapper.h>
 
 #include <mitkImage.h>
 
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionInitializer.h>
 #include <mitkTransferFunctionProperty.h>
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateProperty.h>
 
 #include <mitkProperties.h>
 
 const std::string QmitkVolumeVisualizationView::VIEW_ID = "org.mitk.views.volumevisualization";
 
 enum
 {
   DEFAULT_RENDERMODE = 0,
   RAYCAST_RENDERMODE = 1,
   GPU_RENDERMODE = 2
 };
 
 QmitkVolumeVisualizationView::QmitkVolumeVisualizationView()
   : QmitkAbstractView()
   , m_Controls(nullptr)
 {
 }
 
 void QmitkVolumeVisualizationView::SetFocus()
 {
 }
 
 void QmitkVolumeVisualizationView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls = new Ui::QmitkVolumeVisualizationViewControls;
   m_Controls->setupUi(parent);
 
   m_Controls->volumeSelectionWidget->SetDataStorage(GetDataStorage());
   m_Controls->volumeSelectionWidget->SetNodePredicate(mitk::NodePredicateAnd::New(
     mitk::TNodePredicateDataType<mitk::Image>::New(),
     mitk::NodePredicateOr::New(mitk::NodePredicateDimension::New(3), mitk::NodePredicateDimension::New(4)),
     mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))));
   m_Controls->volumeSelectionWidget->SetSelectionIsOptional(true);
   m_Controls->volumeSelectionWidget->SetEmptyInfo(QString("Please select a 3D / 4D image volume"));
   m_Controls->volumeSelectionWidget->SetPopUpTitel(QString("Select image volume"));
 
   // Fill the transfer function presets in the generator widget
   std::vector<std::string> names;
   mitk::TransferFunctionInitializer::GetPresetNames(names);
   for (const auto& name : names)
   {
     m_Controls->transferFunctionGeneratorWidget->AddPreset(QString::fromStdString(name));
   }
 
   // see vtkVolumeMapper::BlendModes
   m_Controls->blendMode->addItem("Composite", vtkVolumeMapper::COMPOSITE_BLEND);
   m_Controls->blendMode->addItem("Maximum intensity", vtkVolumeMapper::MAXIMUM_INTENSITY_BLEND);
   m_Controls->blendMode->addItem("Minimum intensity", vtkVolumeMapper::MINIMUM_INTENSITY_BLEND);
   m_Controls->blendMode->addItem("Average intensity", vtkVolumeMapper::AVERAGE_INTENSITY_BLEND);
   m_Controls->blendMode->addItem("Additive", vtkVolumeMapper::ADDITIVE_BLEND);
 
   connect(m_Controls->volumeSelectionWidget, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkVolumeVisualizationView::OnCurrentSelectionChanged);
   connect(m_Controls->enableRenderingCB, SIGNAL(toggled(bool)), this, SLOT(OnEnableRendering(bool)));
   connect(m_Controls->blendMode, SIGNAL(activated(int)), this, SLOT(OnBlendMode(int)));
 
   connect(m_Controls->transferFunctionGeneratorWidget, SIGNAL(SignalUpdateCanvas()),
           m_Controls->transferFunctionWidget, SLOT(OnUpdateCanvas()));
   connect(m_Controls->transferFunctionGeneratorWidget, SIGNAL(SignalTransferFunctionModeChanged(int)),
           SLOT(OnMitkInternalPreset(int)));
 
   m_Controls->enableRenderingCB->setEnabled(false);
   m_Controls->blendMode->setEnabled(false);
   m_Controls->transferFunctionWidget->setEnabled(false);
   m_Controls->transferFunctionGeneratorWidget->setEnabled(false);
 
   m_Controls->volumeSelectionWidget->SetAutoSelectNewNodes(true);
 
   this->m_TimePointChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
   connect(&m_TimePointChangeListener,
           &QmitkSliceNavigationListener::SelectedTimePointChanged,
           this,
           &QmitkVolumeVisualizationView::OnSelectedTimePointChanged);
 }
 
 void QmitkVolumeVisualizationView::RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart)
 {
   this->m_TimePointChangeListener.RenderWindowPartActivated(renderWindowPart);
 }
 
 void QmitkVolumeVisualizationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart *renderWindowPart)
 {
   this->m_TimePointChangeListener.RenderWindowPartDeactivated(renderWindowPart);
 }
 
 void QmitkVolumeVisualizationView::OnMitkInternalPreset(int mode)
 {
-  if (m_SelectedNode.IsExpired())
+  auto node = m_SelectedNode.Lock();
+
+  if (node.IsNull())
   {
     return;
   }
 
-  auto node = m_SelectedNode.Lock();
   mitk::TransferFunctionProperty::Pointer transferFuncProp;
   if (node->GetProperty(transferFuncProp, "TransferFunction"))
   {
     // first item is only information
     if (--mode == -1)
       return;
 
     // -- Creat new TransferFunction
     mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(transferFuncProp->GetValue());
     tfInit->SetTransferFunctionMode(mode);
     RequestRenderWindowUpdate();
     m_Controls->transferFunctionWidget->OnUpdateCanvas();
   }
 }
 
 void QmitkVolumeVisualizationView::OnCurrentSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   m_SelectedNode = nullptr;
 
   if (nodes.empty() || nodes.front().IsNull())
   {
     UpdateInterface();
     return;
   }
 
   auto selectedNode = nodes.front();
   auto image = dynamic_cast<mitk::Image*>(selectedNode->GetData());
   if (nullptr != image)
   {
     m_SelectedNode = selectedNode;
   }
 
   UpdateInterface();
 }
 
 void QmitkVolumeVisualizationView::OnEnableRendering(bool state)
 {
-  if (m_SelectedNode.IsExpired())
+  auto selectedNode = m_SelectedNode.Lock();
+
+  if (selectedNode.IsNull())
   {
     return;
   }
 
-  m_SelectedNode.Lock()->SetProperty("volumerendering", mitk::BoolProperty::New(state));
+  selectedNode->SetProperty("volumerendering", mitk::BoolProperty::New(state));
   UpdateInterface();
   RequestRenderWindowUpdate();
 }
 
 void QmitkVolumeVisualizationView::OnBlendMode(int index)
 {
-  if (m_SelectedNode.IsExpired())
+  auto selectedNode = m_SelectedNode.Lock();
+
+  if (selectedNode.IsNull())
     return;
 
-  auto selectedNode = m_SelectedNode.Lock();
   int mode = m_Controls->blendMode->itemData(index).toInt();
   selectedNode->SetProperty("volumerendering.blendmode", mitk::IntProperty::New(mode));
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkVolumeVisualizationView::OnSelectedTimePointChanged(const mitk::TimePointType & /*newTimePoint*/)
 {
   this->UpdateInterface();
 }
 
 void QmitkVolumeVisualizationView::UpdateInterface()
 {
   if (m_SelectedNode.IsExpired())
   {
     // turnoff all
     m_Controls->enableRenderingCB->setChecked(false);
     m_Controls->enableRenderingCB->setEnabled(false);
 
     m_Controls->blendMode->setCurrentIndex(0);
     m_Controls->blendMode->setEnabled(false);
 
     m_Controls->transferFunctionWidget->SetDataNode(nullptr);
     m_Controls->transferFunctionWidget->setEnabled(false);
 
     m_Controls->transferFunctionGeneratorWidget->SetDataNode(nullptr);
     m_Controls->transferFunctionGeneratorWidget->setEnabled(false);
     return;
   }
 
   bool enabled = false;
   auto selectedNode = m_SelectedNode.Lock();
 
   selectedNode->GetBoolProperty("volumerendering", enabled);
   m_Controls->enableRenderingCB->setEnabled(true);
   m_Controls->enableRenderingCB->setChecked(enabled);
 
   if (!enabled)
   {
     // turnoff all except volumerendering checkbox
     m_Controls->blendMode->setCurrentIndex(0);
     m_Controls->blendMode->setEnabled(false);
 
     m_Controls->transferFunctionWidget->SetDataNode(nullptr);
     m_Controls->transferFunctionWidget->setEnabled(false);
 
     m_Controls->transferFunctionGeneratorWidget->SetDataNode(nullptr);
     m_Controls->transferFunctionGeneratorWidget->setEnabled(false);
     return;
   }
 
   // otherwise we can activate em all
   m_Controls->blendMode->setEnabled(true);
 
   // Determine Combo Box mode
   int blendMode;
   if (selectedNode->GetIntProperty("volumerendering.blendmode", blendMode))
     m_Controls->blendMode->setCurrentIndex(blendMode);
 
   auto time = this->GetRenderWindowPart()->GetTimeNavigationController()->GetSelectedTimeStep();
   m_Controls->transferFunctionWidget->SetDataNode(selectedNode, time);
   m_Controls->transferFunctionWidget->setEnabled(true);
   m_Controls->transferFunctionGeneratorWidget->SetDataNode(selectedNode, time);
   m_Controls->transferFunctionGeneratorWidget->setEnabled(true);
 }
diff --git a/README.md b/README.md
index d70d478725..7285997530 100644
--- a/README.md
+++ b/README.md
@@ -1,110 +1,110 @@
 ![MITK Logo][logo]
 
 The [Medical Imaging Interaction Toolkit][mitk] (MITK) is a free open-source software
 system for development of interactive medical image processing software. MITK
 combines the [Insight Toolkit][itk] (ITK) and the [Visualization Toolkit][vtk] (VTK) with an application framework.
 
 The links below provide high-level and reference documentation targeting different
 usage scenarios:
 
  - Get a [high-level overview][mitk-overview] about MITK with pointers to further
    documentation
  - End-users looking for help with MITK applications should read the
    [MITK User Manual][mitk-usermanual]
  - Developers contributing to or using MITK, please see the [MITK Developer Manual][mitk-devmanual]
    as well as the [MITK API Reference][mitk-apiref]
 
 See the [MITK homepage][mitk] for details.
 
 Supported platforms
 -------------------
 
 MITK is a cross-platform C++ toolkit and officially supports:
 
  - Windows
  - Linux
  - macOS
 
 For details, please read the [Supported Platforms][platforms] page.
 
 ### Build status of develop branch
 
 [![Windows][windows-build-status]][cdash]
 [![Ubuntu 18.04][ubuntu-18.04-build-status]][cdash]
 [![Ubuntu 20.04][ubuntu-20.04-build-status]][cdash]
 [![macOS 10.15 Catalina][macos-10.15-build-status]][cdash]
 [![macOS 11 Big Sur][macos-11-build-status]][cdash]
 
 We highly recommend to use the stable **master** branch instead. It is updated 1-2 times per month accompanied by curated [changelogs][changelog] and [snapshot installers][snapshot-installers].
 
 License
 -------
 
 Copyright (c) [German Cancer Research Center (DKFZ)][dkfz]. All rights reserved.
 
 MITK is available as free open-source software under a [3-clause BSD license][license].
 
 Download
 --------
 
 The MITK source code and binaries for the *MitkWorkbench* application are released regularly according to the [MITK release cycle][release-cycle]. See the [Download][download] page for a list of releases.
 
 The official MITK source code is available in the [MITK Git repository][phab_repo]. The Git clone command is
 
     git clone https://phabricator.mitk.org/source/mitk.git MITK
 
 Active development takes place in the MITK develop branch and its usage is advised for advanced users only.
 
 How to contribute
 -----------------
 
 Contributions of all kind are happily accepted. However, to make the contribution process as smooth as possible, please read the [How to contribute to MITK][contribute] page if you plan to contribute to MITK.
 
 Build instructions
 ------------------
 
 MITK uses [CMake][cmake] to configure a build tree. The following is a crash course about cloning, configuring, and building MITK on a Linux/Unix system:
 
     git clone https://phabricator.mitk.org/source/mitk.git MITK
     mkdir MITK-build
     cd MITK-build
     cmake ../MITK
     make -j4
 
 Read the comprehensive [build instructions][build] page for details.
 
 Useful links
 ------------
 
  - [Homepage][mitk]
  - [Download][download]
  - [Mailing list][mailinglist]
  - [Issue tracker][bugs]
 
 [logo]: https://github.com/MITK/MITK/raw/master/mitk.png
 [mitk]: https://www.mitk.org
 [itk]: https://itk.org
 [vtk]: https://vtk.org
-[mitk-overview]: https://docs.mitk.org/2022.04/
-[mitk-usermanual]: https://docs.mitk.org/2022.04/UserManualPortal.html
-[mitk-devmanual]: https://docs.mitk.org/2022.04/DeveloperManualPortal.html
-[mitk-apiref]: https://docs.mitk.org/2022.04/usergroup0.html
-[platforms]: https://docs.mitk.org/2022.04/SupportedPlatformsPage.html
+[mitk-overview]: https://docs.mitk.org/nightly/
+[mitk-usermanual]: https://docs.mitk.org/nightly/UserManualPortal.html
+[mitk-devmanual]: https://docs.mitk.org/nightly/DeveloperManualPortal.html
+[mitk-apiref]: https://docs.mitk.org/nightly/usergroup0.html
+[platforms]: https://docs.mitk.org/nightly/SupportedPlatformsPage.html
 [dkfz]: https://www.dkfz.de
 [license]: https://github.com/MITK/MITK/blob/master/LICENSE
 [release-cycle]: https://www.mitk.org/MitkReleaseCycle
 [download]: https://www.mitk.org/Download
 [phab_repo]: https://phabricator.mitk.org/source/mitk/
 [contribute]: https://www.mitk.org/How_to_contribute
 [cmake]: https://www.cmake.org
-[build]: https://docs.mitk.org/2022.04/BuildInstructionsPage.html
+[build]: https://docs.mitk.org/nightly/BuildInstructionsPage.html
 [mailinglist]: https://www.mitk.org/Mailinglist
 [bugs]: https://phabricator.mitk.org/maniphest/
 [cdash]: https://cdash.mitk.org/index.php?project=MITK
 [changelog]: https://phabricator.mitk.org/w/mitk/changelog/
 [snapshot-installers]: https://www.mitk.org/download/ci/snapshots/
 [windows-build-status]: https://ci.mitk.org/buildStatus/icon?job=MITK%2FContinuous%2FWindows&subject=Windows
 [ubuntu-18.04-build-status]: https://ci.mitk.org/buildStatus/icon?job=MITK%2FContinuous%2FUbuntu+18.04&subject=Ubuntu+18.04
 [ubuntu-20.04-build-status]: https://ci.mitk.org/buildStatus/icon?job=MITK%2FContinuous%2FUbuntu+20.04&subject=Ubuntu+20.04
 [macOS-10.15-build-status]: https://ci.mitk.org/buildStatus/icon?job=MITK%2FContinuous%2FmacOS+Catalina&subject=macOS+10.15+Catalina
 [macOS-11-build-status]: https://ci.mitk.org/buildStatus/icon?job=MITK%2FContinuous%2FmacOS+Big+Sur&subject=macOS+11+Big+Sur