diff --git a/Applications/mitkWorkbench/mitkWorkbench.cpp b/Applications/mitkWorkbench/mitkWorkbench.cpp
index 36c3b32584..51589f56b8 100644
--- a/Applications/mitkWorkbench/mitkWorkbench.cpp
+++ b/Applications/mitkWorkbench/mitkWorkbench.cpp
@@ -1,150 +1,150 @@
 /*===================================================================
 
 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 <application/berryStarter.h>
 #include <Poco/Util/MapConfiguration.h>
 
 #include <QApplication>
 #include <QMessageBox>
 #include <QtSingleApplication>
 #include <QtGlobal>
 #include <QTime>
 
 #include <mitkCommon.h>
 #include <mitkException.h>
 
 class QtSafeApplication : public QtSingleApplication
 {
 
 public:
 
   QtSafeApplication(int& argc, char** argv) : QtSingleApplication(argc, argv)
   {}
 
   /**
    * Reimplement notify to catch unhandled exceptions and open an error message.
    *
    * @param receiver
    * @param event
    * @return
    */
   bool notify(QObject* receiver, QEvent* event)
   {
     QString msg;
     try
     {
       return QApplication::notify(receiver, event);
     }
     catch (mitk::Exception& e)
     {
       msg = QString("MITK Exception:\n\n") 
             + QString("Desciption: ") 
             + QString(e.GetDescription()) + QString("\n\n")
             + QString("Filename: ") + QString(e.GetFile()) + QString("\n\n")
             + QString("Line: ") + QString::number(e.GetLine());
     }
     catch (Poco::Exception& e)
     {
       msg = QString::fromStdString(e.displayText());
     }
     catch (std::exception& e)
     {
       msg = e.what();
     }
     catch (...)
     {
       msg = "Unknown exception";
     }
     MITK_ERROR << "An error occurred: " << msg.toStdString();
 
     QMessageBox msgBox;
     msgBox.setText("An error occurred. You should save all data and quit the program to prevent possible data loss.");
     msgBox.setDetailedText(msg);
     msgBox.setIcon(QMessageBox::Critical);
     msgBox.addButton(trUtf8("Exit immediately"), QMessageBox::YesRole);
     msgBox.addButton(trUtf8("Ignore"), QMessageBox::NoRole);
 
     int ret = msgBox.exec();
     
     switch(ret)
       {
       case 0:
         MITK_ERROR << "The program was closed.";
         this->closeAllWindows();
         break;
       case 1:
         MITK_ERROR << "The error was ignored by the user. The program may be in a corrupt state and don't behave like expected!";
         break;
       }
 
     return false;
   }
 
 };
 
 
 int main(int argc, char** argv)
 {
   // Create a QApplication instance first
   QtSafeApplication qSafeApp(argc, argv);
-  qSafeApp.setApplicationName("mitkWorkbench");
+  qSafeApp.setApplicationName("MITK Workbench");
   qSafeApp.setOrganizationName("DKFZ");
 
   // 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.
   QString storageDir = handleNewAppInstance(&qSafeApp, argc, argv, "BlueBerry.newInstance");
 
   // These paths replace the .ini file and are tailored for installation
   // packages created with CPack. If a .ini file is presented, it will
   // overwrite the settings in MapConfiguration
   Poco::Path basePath(argv[0]);
   basePath.setFileName("");
   
   Poco::Path provFile(basePath);
   provFile.setFileName("mitkWorkbench.provisioning");
 
   Poco::Path extPath(basePath);
   extPath.pushDirectory("ExtBundles");
 
   std::string pluginDirs = extPath.toString();
 
   Poco::Util::MapConfiguration* extConfig(new Poco::Util::MapConfiguration());
   if (!storageDir.isEmpty())
   {
     extConfig->setString(berry::Platform::ARG_STORAGE_DIR, storageDir.toStdString());
   }
   extConfig->setString(berry::Platform::ARG_PLUGIN_DIRS, pluginDirs);
   extConfig->setString(berry::Platform::ARG_PROVISIONING, provFile.toString());
   extConfig->setString(berry::Platform::ARG_APPLICATION, "org.mitk.qt.extapplication");
 
   // Preload the org.mitk.gui.qt.ext plug-in (and hence also QmitkExt) to speed
   // up a clean-cache start. This also works around bugs in older gcc and glibc implementations,
   // which have difficulties with multiple dynamic opening and closing of shared libraries with
   // many global static initializers. It also helps if dependent libraries have weird static
   // initialization methods and/or missing de-initialization code.
   extConfig->setString(berry::Platform::ARG_PRELOAD_LIBRARY, "liborg_mitk_gui_qt_ext,libCTKDICOMCore:0.1");
 
   // Seed the random number generator, once at startup.
   QTime time = QTime::currentTime();
   qsrand((uint)time.msec());
 
   // Run the workbench.
   return berry::Starter::Run(argc, argv, extConfig);
 }
diff --git a/CMake/mitkFunctionGetVersionDescription.cmake b/CMake/mitkFunctionGetVersionDescription.cmake
new file mode 100644
index 0000000000..816fd5e79a
--- /dev/null
+++ b/CMake/mitkFunctionGetVersionDescription.cmake
@@ -0,0 +1,60 @@
+#! \brief Extract the version description from a local working copy
+#!
+#! If the given repository is a git repository, the functions runs the
+#! git rev-parse --exact-match HEAD command 
+#!
+#! Information provided is stored in  ${prefix}_REVISION_DESC an is
+#! \ul
+#!  \li The exact tag if the HEAD of the source-tree has a tag
+#!  \li the 'git describe' output, which is <latest-reachable-tag>-<#Commits>-g<SHORT-HASH>
+#! \lu
+#! In case the working copy contains local changes, the ${prefix}_REVISION_DESC strings will contain
+#! a suffix [local changes]
+#!
+#! \param source_dir The directory containing a working copy
+#! \param prefix A prefix to prepent to the variables containing
+#!               the extracted information
+#!
+function(mitkFunctionGetVersionDescription source_dir prefix)
+
+  if(NOT prefix)
+    message(FATAL_ERROR "prefix argument not specified")
+  endif()
+
+  # initialize variable
+  set(_wc_description "NO TAG FOUND")
+  set(_dirty_repo_str " [local changes]")
+
+  find_package(Git)
+  if(GIT_FOUND)
+  
+    GIT_IS_REPO(${source_dir} _is_git_repo)
+    if(_is_git_repo)
+      execute_process(COMMAND git describe --exact-match --dirty=${_dirty_repo_str}
+                      WORKING_DIRECTORY ${source_dir} 
+                      OUTPUT_VARIABLE _project_git_tagname
+                      RESULT_VARIABLE _proper_version
+                      ERROR_VARIABLE _description_error )
+
+      if(_proper_version EQUAL 0 )
+        set(_wc_description ${_project_git_tagname})
+  
+      else(_proper_version EQUAL 0)
+        # the execution failed, i.e. the HEAD has no tag, 
+        # for fallback string: execute again but without the --exact-match
+        execute_process(COMMAND git describe --dirty=${_dirty_repo_str}
+                    WORKING_DIRECTORY ${source_dir} 
+                    OUTPUT_VARIABLE _wc_description
+                    RESULT_VARIABLE _proper_version
+                    ERROR_VARIABLE _description_error)
+      endif()
+
+      # remove newline at and of the string
+      string(STRIP "${_wc_description}" _wc_description)
+
+    endif()
+  endif()
+
+  set(${prefix}_REVISION_DESC ${_wc_description} PARENT_SCOPE )
+
+endfunction()
diff --git a/CMake/mitkSetupVariables.cmake b/CMake/mitkSetupVariables.cmake
index 8c46264c49..9651c54e44 100644
--- a/CMake/mitkSetupVariables.cmake
+++ b/CMake/mitkSetupVariables.cmake
@@ -1,166 +1,166 @@
 if(MITK_BUILD_ALL_PLUGINS)
   set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
 endif()
 
 set(LIBPOSTFIX "")
 
 # MITK_VERSION
 set(MITK_VERSION_MAJOR "2012")
-set(MITK_VERSION_MINOR "06")
-set(MITK_VERSION_PATCH "99")
+set(MITK_VERSION_MINOR "09")
+set(MITK_VERSION_PATCH "00")
 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()
 
 #-----------------------------------
 # Configuration of module system
 #-----------------------------------
 set(MODULES_CONF_DIRNAME modulesConf)
 set(MODULES_CONF_DIRS ${MITK_BINARY_DIR}/${MODULES_CONF_DIRNAME})
 
 if(NOT UNIX AND NOT MINGW)
   set(MITK_WIN32_FORCE_STATIC "STATIC" CACHE INTERNAL "Use this variable to always build static libraries on non-unix platforms")
 endif()
 
 # build the MITK_INCLUDE_DIRS variable
 set(MITK_INCLUDE_DIRS
     ${ITK_INCLUDE_DIRS}
     ${VTK_INCLUDE_DIRS}
     ${PROJECT_BINARY_DIR} # contains mitkConfig.h and similar files
     ${MODULES_CONF_DIRS} # contains module *Exports.h files
    )
 set(CORE_DIRECTORIES Common DataManagement Algorithms IO Rendering Interactions Controllers Service)
 foreach(d ${CORE_DIRECTORIES})
   list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/Core/Code/${d})
 endforeach()
 #list(APPEND MITK_INCLUDE_DIRS  
      #${ITK_INCLUDE_DIRS}
      #${VTK_INCLUDE_DIRS}
 #    )
      
 foreach(d Utilities Utilities/ipPic Utilities/pic2vtk Utilities/tinyxml Utilities/mbilog)
   list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/${d})
 endforeach()
 list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/Utilities/mbilog)
 
 if(WIN32)
   list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipPic/win32)
 endif()
 
 # additional include dirs variables
 set(ANN_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ann/include)
 set(IPSEGMENTATION_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipSegmentation)
 
 # variables containing librariy names
 set(MITK_CORE_LIBRARIES Mitk)
 set(VTK_FOR_MITK_LIBRARIES
     vtkGraphics
     vtkCommon
     vtkFiltering
     vtkftgl
     vtkGraphics
     vtkHybrid
     vtkImaging
     vtkIO
     vtkParallel
     vtkRendering
     vtkVolumeRendering
     vtkWidgets
     ${VTK_JPEG_LIBRARIES}
     ${VTK_PNG_LIBRARIES}
     ${VTK_ZLIB_LIBRARIES}
     ${VTK_EXPAT_LIBRARIES}
     ${VTK_FREETYPE_LIBRARIES}
    )
 # TODO: maybe solve this with lib depends mechanism of CMake
 set(UTIL_FOR_MITK_LIBRARIES mitkIpPic mitkIpFunc mbilog)
 set(LIBRARIES_FOR_MITK_CORE
     ${UTIL_FOR_MITK_LIBRARIES}
     ${VTK_FOR_MITK_LIBRARIES}
     ${ITK_LIBRARIES}
    )
 set(MITK_LIBRARIES
     ${MITK_CORE_LIBRARIES}
     ${LIBRARIES_FOR_MITK_CORE}
     pic2vtk
     ipSegmentation
     ann 
    )
    
 # variables used in CMake macros which are called from external projects
 set(MITK_VTK_LIBRARY_DIRS ${VTK_LIBRARY_DIRS})
 set(MITK_ITK_LIBRARY_DIRS ${ITK_LIBRARY_DIRS})
 
 # variables containing link directories
 set(MITK_LIBRARY_DIRS ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})                                                                                                              
 set(MITK_LINK_DIRECTORIES
     ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
     ${ITK_LIBRARY_DIRS}
     ${VTK_LIBRARY_DIRS}
     ${GDCM_LIBRARY_DIRS})
 
 # Qt support
 if(MITK_USE_QT)
   find_package(Qt4 REQUIRED)
 
   set(QMITK_INCLUDE_DIRS 
       ${MITK_INCLUDE_DIRS}
       ${CMAKE_CURRENT_SOURCE_DIR}/Modules/Qmitk
       ${PROJECT_BINARY_DIR}/Modules/Qmitk
      )
   
   set(QMITK_LIBRARIES Qmitk ${MITK_LIBRARIES})
   set(QMITK_LINK_DIRECTORIES ${MITK_LINK_DIRECTORIES})
 endif()
 
 if(MITK_BUILD_ALL_PLUGINS)
   set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
 endif()
 
 # create a list of types for template instantiations of itk image access functions
 function(_create_type_seq TYPES seq_var seqdim_var)
   set(_seq )
   set(_seq_dim )
   string(REPLACE "," ";" _pixeltypes "${TYPES}")
   foreach(_pixeltype ${_pixeltypes})
     set(_seq "${_seq}(${_pixeltype})")
     set(_seq_dim "${_seq_dim}((${_pixeltype},dim))")
   endforeach()
   set(${seq_var} "${_seq}" PARENT_SCOPE)
   set(${seqdim_var} "${_seq_dim}" PARENT_SCOPE)
 endfunction()
 
 set(MITK_ACCESSBYITK_PIXEL_TYPES )
 set(MITK_ACCESSBYITK_PIXEL_TYPES_SEQ )
 set(MITK_ACCESSBYITK_TYPES_DIMN_SEQ )
 # concatenate only the simple pixel types to the MITK_ACCESSBYITK_PIXEL_TYPE_SEQ list
 # see Bug 12682 for detailed information
 foreach(_type INTEGRAL FLOATING)
   set(_typelist "${MITK_ACCESSBYITK_${_type}_PIXEL_TYPES}")
   if(_typelist)
     if(MITK_ACCESSBYITK_PIXEL_TYPES)
       set(MITK_ACCESSBYITK_PIXEL_TYPES "${MITK_ACCESSBYITK_PIXEL_TYPES},${_typelist}")
     else()
       set(MITK_ACCESSBYITK_PIXEL_TYPES "${_typelist}")
     endif()
   endif()
 
   _create_type_seq("${_typelist}"
                    MITK_ACCESSBYITK_${_type}_PIXEL_TYPES_SEQ
                    MITK_ACCESSBYITK_${_type}_TYPES_DIMN_SEQ)
   set(MITK_ACCESSBYITK_PIXEL_TYPES_SEQ "${MITK_ACCESSBYITK_PIXEL_TYPES_SEQ}${MITK_ACCESSBYITK_${_type}_PIXEL_TYPES_SEQ}")
   set(MITK_ACCESSBYITK_TYPES_DIMN_SEQ "${MITK_ACCESSBYITK_TYPES_DIMN_SEQ}${MITK_ACCESSBYITK_${_type}_TYPES_DIMN_SEQ}")
 endforeach()
 
 # separate processing of the COMPOSITE list to avoid its concatenation to to global list
 _create_type_seq(${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
                  MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ
                  MITK_ACCESSBYITK_COMPOSITE_TYPES_DIMN_SEQ)
 
 set(MITK_ACCESSBYITK_DIMENSIONS_SEQ )
 string(REPLACE "," ";" _dimensions "${MITK_ACCESSBYITK_DIMENSIONS}")
 foreach(_dimension ${_dimensions})
   set(MITK_ACCESSBYITK_DIMENSIONS_SEQ "${MITK_ACCESSBYITK_DIMENSIONS_SEQ}(${_dimension})")
 endforeach()
 
diff --git a/CMakeExternals/CTK.cmake b/CMakeExternals/CTK.cmake
index a647402efb..442538a0a3 100644
--- a/CMakeExternals/CTK.cmake
+++ b/CMakeExternals/CTK.cmake
@@ -1,81 +1,81 @@
 #-----------------------------------------------------------------------------
 # CTK
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_CTK)
 
   # Sanity checks
   if(DEFINED CTK_DIR AND NOT EXISTS ${CTK_DIR})
     message(FATAL_ERROR "CTK_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj CTK)
   set(proj_DEPENDENCIES )
   set(CTK_DEPENDS ${proj})
 
   if(NOT DEFINED CTK_DIR)
     
-    set(revision_tag f8d63311)
+    set(revision_tag f25f19e5)
     #IF(${proj}_REVISION_TAG)
     #  SET(revision_tag ${${proj}_REVISION_TAG})
     #ENDIF()
     
     set(ctk_optional_cache_args )
     if(MITK_USE_Python)
       list(APPEND ctk_optional_cache_args
            -DCTK_LIB_Scripting/Python/Widgets:BOOL=ON
       )
     endif()
 
     if(MITK_USE_DCMTK)
       list(APPEND ctk_optional_cache_args
            -DDCMTK_DIR:PATH=${DCMTK_DIR}
           )
       list(APPEND proj_DEPENDENCIES DCMTK)
     else()
       list(APPEND ctk_optional_cache_args
            -DDCMTK_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_DCMTK_085525e6.tar.gz
           )
     endif()
 
     FOREACH(type RUNTIME ARCHIVE LIBRARY)
       IF(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY)
         LIST(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY})
       ENDIF()
     ENDFOREACH()
 
     ExternalProject_Add(${proj}
       SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
       BINARY_DIR ${proj}-build
       PREFIX ${proj}-cmake
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_${revision_tag}.tar.gz
-      URL_MD5 cbd57918a076d6c3830313c01724ceaf
+      URL_MD5 70fadbc62ec5c7d83a6e672fd5be36b1
       UPDATE_COMMAND ""
       INSTALL_COMMAND ""
       CMAKE_GENERATOR ${gen}
       CMAKE_ARGS
         ${ep_common_args}
         ${ctk_optional_cache_args}
         -DDESIRED_QT_VERSION:STRING=4
         -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
         -DGit_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}
         -DGIT_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}
         -DCTK_LIB_CommandLineModules/Backend/LocalProcess:BOOL=ON
         -DCTK_LIB_CommandLineModules/Frontend/QtGui:BOOL=ON
         -DCTK_LIB_PluginFramework:BOOL=ON
         -DCTK_LIB_DICOM/Widgets:BOOL=ON
         -DCTK_PLUGIN_org.commontk.eventadmin:BOOL=ON
         -DCTK_PLUGIN_org.commontk.configadmin:BOOL=ON
         -DCTK_USE_GIT_PROTOCOL:BOOL=OFF
         -DDCMTK_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_DCMTK_085525e6.tar.gz
       DEPENDS ${proj_DEPENDENCIES}
      )
   set(CTK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
   
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
     
   endif()
   
 endif()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 75a1ae56f3..57a82616b2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,916 +1,918 @@
 if(APPLE)
   # With XCode 4.3, the SDK location changed. Older CMake
   # versions are not able to find it.
   cmake_minimum_required(VERSION 2.8.8)
 else()
   cmake_minimum_required(VERSION 2.8.4)
 endif()
 
 #-----------------------------------------------------------------------------
 # 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()
 
 #-----------------------------------------------------------------------------
 # 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)
 endif()
 
 #-----------------------------------------------------------------------------
 # 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 43) # _src_dir_length_max - strlen(ITK-src)
     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()
 
 #-----------------------------------------------------------------------------
 # See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details
 #-----------------------------------------------------------------------------
 
 set(project_policies
   CMP0001 # NEW: CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.
   CMP0002 # NEW: Logical target names must be globally unique.
   CMP0003 # NEW: Libraries linked via full path no longer produce linker search paths.
   CMP0004 # NEW: Libraries linked may NOT have leading or trailing whitespace.
   CMP0005 # NEW: Preprocessor definition values are now escaped automatically.
   CMP0006 # NEW: Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.
   CMP0007 # NEW: List command no longer ignores empty elements.
   CMP0008 # NEW: Libraries linked by full-path must have a valid library file name.
   CMP0009 # NEW: FILE GLOB_RECURSE calls should not follow symlinks by default.
   CMP0010 # NEW: Bad variable reference syntax is an error.
   CMP0011 # NEW: Included scripts do automatic cmake_policy PUSH and POP.
   CMP0012 # NEW: if() recognizes numbers and boolean constants.
   CMP0013 # NEW: Duplicate binary directories are not allowed.
   CMP0014 # NEW: Input directories must have CMakeLists.txt
   )
 foreach(policy ${project_policies})
   if(POLICY ${policy})
     cmake_policy(SET ${policy} NEW)
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #------------------------------------------------------------------------------
 
 set(CMAKE_MODULE_PATH
   ${MITK_SOURCE_DIR}/CMake
   ${CMAKE_MODULE_PATH}
   )
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(mitkMacroEmptyExternalProject)
 include(mitkFunctionGenerateProjectXml)
 include(mitkFunctionSuppressWarnings)
 
 SUPPRESS_VC_DEPRECATED_WARNINGS()
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 foreach(type LIBRARY RUNTIME ARCHIVE)
   # Make sure the directory exists
   if(DEFINED 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_USE_SUPERBUILD)
     set(output_dir ${MITK_BINARY_DIR}/bin)
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_BINARY_DIR}/MITK-build/bin)
     endif()
   else()
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(output_dir ${MITK_BINARY_DIR}/bin)
     else()
       set(output_dir ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     endif()
   endif()
   set(CMAKE_${type}_OUTPUT_DIRECTORY ${output_dir} CACHE INTERNAL "Single output directory for building all libraries.")
   mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Additional MITK Options (also shown during superbuild)
 #-----------------------------------------------------------------------------
 
 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_BUILD_ALL_APPS "Build all MITK applications" OFF)
 set(MITK_BUILD_TUTORIAL OFF CACHE INTERNAL "Deprecated! Use MITK_BUILD_EXAMPLES instead!")
 option(MITK_BUILD_EXAMPLES "Build the MITK Examples" ${MITK_BUILD_TUTORIAL})
 option(MITK_USE_Boost "Use the Boost C++ library" OFF)
 option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
 option(MITK_USE_CTK "Use CTK in MITK" ${MITK_USE_BLUEBERRY})
 option(MITK_USE_QT "Use Nokia's Qt library" ${MITK_USE_CTK})
 option(MITK_USE_DCMTK "EXPERIMENTAL, superbuild only: Use DCMTK in MITK" ${MITK_USE_CTK})
 option(MITK_DCMTK_BUILD_SHARED_LIBS "EXPERIMENTAL, superbuild only: build DCMTK as shared libs" OFF)
 option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF)
 option(MITK_USE_Python "Use Python wrapping in MITK" OFF)
 set(MITK_USE_CableSwig ${MITK_USE_Python})
 
 mark_as_advanced(MITK_BUILD_ALL_APPS
                  MITK_USE_CTK
                  MITK_USE_DCMTK
                 )
 
 
 if(MITK_USE_Boost)
   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")
 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()
   
 if(MITK_USE_CTK)
   if(NOT MITK_USE_QT)
     message("Forcing MITK_USE_QT to ON because of MITK_USE_CTK")
     set(MITK_USE_QT ON CACHE BOOL "Use Nokia's Qt library in MITK" FORCE)
   endif()
   if(NOT MITK_USE_DCMTK)
     message("Setting MITK_USE_DCMTK to ON because DCMTK needs to be build for CTK")
     set(MITK_USE_DCMTK ON CACHE BOOL "Use DCMTK in MITK" FORCE)
   endif()
 endif()
 
 if(MITK_USE_QT)
   # find the package at the very beginning, so that QT4_FOUND is available
   find_package(Qt4 4.6.2 REQUIRED)
 endif()
 
 
 # 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_DIMENSIONS)
   set(MITK_ACCESSBYITK_DIMENSIONS
       "2,3"
       CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 endif()
 
 #-----------------------------------------------------------------------------
 # Additional CXX/C Flags
 #-----------------------------------------------------------------------------
 
 set(ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags")
 mark_as_advanced(ADDITIONAL_C_FLAGS)
 set(ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags")
 mark_as_advanced(ADDITIONAL_CXX_FLAGS)
 
 #-----------------------------------------------------------------------------
 # Project.xml
 #-----------------------------------------------------------------------------
 
 # A list of topologically ordered targets
 set(CTEST_PROJECT_SUBPROJECTS)
 if(MITK_USE_BLUEBERRY)
   list(APPEND CTEST_PROJECT_SUBPROJECTS BlueBerry)
 endif()
 
 list(APPEND CTEST_PROJECT_SUBPROJECTS
   MITK-Core
   MITK-CoreUI
   MITK-IGT
   MITK-ToF
   MITK-DTI
   MITK-Registration
   MITK-Modules # all modules not contained in a specific subproject
   MITK-Plugins # all plugins not contained in a specific subproject
   MITK-Examples
   Unlabeled # special "subproject" catching all unlabeled targets and tests
   )
 
 # Configure CTestConfigSubProject.cmake that could be used by CTest scripts
 configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in
                ${MITK_BINARY_DIR}/CTestConfigSubProject.cmake)
                
 if(CTEST_PROJECT_ADDITIONAL_TARGETS)
   # those targets will be executed at the end of the ctest driver script
   # and they also get their own subproject label
   set(subproject_list "${CTEST_PROJECT_SUBPROJECTS};${CTEST_PROJECT_ADDITIONAL_TARGETS}")
 else()
   set(subproject_list "${CTEST_PROJECT_SUBPROJECTS}")
 endif()
 
 # Generate Project.xml file expected by the CTest driver script
 mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} MITK "${subproject_list}" ${MITK_USE_SUPERBUILD})
 
 #-----------------------------------------------------------------------------
 # Superbuild script
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_SUPERBUILD)
   include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
   return()
 endif()
 
 #*****************************************************************************
 #****************************  END OF SUPERBUILD  ****************************
 #*****************************************************************************
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(CheckCXXSourceCompiles)
 include(mitkFunctionCheckCompilerFlags)
 include(mitkFunctionGetGccVersion)
 include(MacroParseArguments)
 include(mitkFunctionSuppressWarnings) # includes several functions
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionGetVersion)
+include(mitkFunctionGetVersionDescription)
 include(mitkFunctionCreateWindowsBatchScript)
 include(mitkFunctionInstallProvisioningFiles)
 include(mitkFunctionCompileSnippets)
 include(mitkMacroCreateModuleConf)
 include(mitkMacroCreateModule)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 include(mitkMacroGetLinuxDistribution)
 
 #-----------------------------------------------------------------------------
 # Prerequesites
 #-----------------------------------------------------------------------------
 
 find_package(ITK REQUIRED)
 find_package(VTK REQUIRED)
 
 if(ITK_USE_SYSTEM_GDCM)
   find_package(GDCM PATHS ${ITK_GDCM_DIR} REQUIRED)
 endif()
 
 #-----------------------------------------------------------------------------
 # Set MITK specific options and variables (NOT available during superbuild)
 #-----------------------------------------------------------------------------
 
 # ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and mitkWorkbench
 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)
 
 # TODO: check if necessary
 option(USE_ITKZLIB "Use the ITK zlib for pic compression." ON)
 mark_as_advanced(USE_ITKZLIB)
 
 if(NOT MITK_FAST_TESTING)
   if(DEFINED MITK_CTEST_SCRIPT_MODE 
       AND (MITK_CTEST_SCRIPT_MODE STREQUAL "continuous" OR MITK_CTEST_SCRIPT_MODE STREQUAL "experimental") )
     set(MITK_FAST_TESTING 1)
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Get MITK version info
 #-----------------------------------------------------------------------------
 
 mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
+mitkFunctionGetVersionDescription(${MITK_SOURCE_DIR} MITK)
 
 #-----------------------------------------------------------------------------
 # Installation preparation
 #
 # These should be set before any MITK install macros are used
 #-----------------------------------------------------------------------------
 
 # on Mac OSX all BlueBerry plugins get copied into every
 # application bundle (.app directory) specified here
 if(MITK_USE_BLUEBERRY AND APPLE)
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/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} ${app_name})
     endif()
   endforeach()
 
 endif()
 
 #-----------------------------------------------------------------------------
 # Set symbol visibility Flags
 #-----------------------------------------------------------------------------
 
 # MinGW does not export all symbols automatically, so no need to set flags
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT MINGW)
   set(VISIBILITY_CXX_FLAGS ) #"-fvisibility=hidden -fvisibility-inlines-hidden")
 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} ${ADDITIONAL_C_FLAGS}")
 set(MITK_CXX_FLAGS "${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS} ${ADDITIONAL_CXX_FLAGS}")
 
 include(mitkSetupC++0xVariables)
 
 set(cflags )
 if(WIN32)
   set(cflags "${cflags} -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN")
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   set(cflags "${cflags} -Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings")
 
   mitkFunctionCheckCompilerFlags("-fdiagnostics-show-option" cflags)
   mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" cflags)
   mitkFunctionCheckCompilerFlags("-Wl,--as-needed" cflags)
 
   if(MITK_USE_C++0x)
     mitkFunctionCheckCompilerFlags("-std=c++0x" MITK_CXX_FLAGS)
   endif()
 
   mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
   # With older version of gcc supporting the flag -fstack-protector-all, an extra dependency to libssp.so
   # is introduced. If gcc is smaller than 4.4.0 and the build type is Release let's not include the flag.
   # Doing so should allow to build package made for distribution using older linux distro.
   if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0"))
     mitkFunctionCheckCompilerFlags("-fstack-protector-all" cflags)
   endif()
   if(MINGW)
     # suppress warnings about auto imported symbols
     set(MITK_CXX_FLAGS "-Wl,--enable-auto-import ${MITK_CXX_FLAGS}")
     # we need to define a Windows version
     set(MITK_CXX_FLAGS "-D_WIN32_WINNT=0x0500 ${MITK_CXX_FLAGS}")
   endif()
 
   #set(MITK_CXX_FLAGS "-Woverloaded-virtual -Wold-style-cast -Wstrict-null-sentinel -Wsign-promo ${MITK_CXX_FLAGS}")
   set(MITK_CXX_FLAGS "-Woverloaded-virtual -Wstrict-null-sentinel ${MITK_CXX_FLAGS}")
   set(MITK_CXX_FLAGS_RELEASE "-D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}")
 
 endif()
 
 set(MITK_C_FLAGS "${cflags} ${MITK_C_FLAGS}")
 set(MITK_CXX_FLAGS "${cflags} ${MITK_CXX_FLAGS}")
 
 #-----------------------------------------------------------------------------
 # MITK Packages
 #-----------------------------------------------------------------------------
 
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 
 #-----------------------------------------------------------------------------
 # Testing
 #-----------------------------------------------------------------------------
 
 if(BUILD_TESTING)
   enable_testing()
   include(CTest)
   mark_as_advanced(TCL_TCLSH DART_ROOT)
 
   option(MITK_ENABLE_GUI_TESTING OFF "Enable the MITK GUI tests")
 
   # Setup file for setting custom ctest vars
   configure_file(
     CMake/CTestCustom.cmake.in
     ${MITK_BINARY_DIR}/CTestCustom.cmake
     @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( std::exception & excp )
         {
         fprintf(stderr,\"%s\\n\",excp.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 external project template
   if(MITK_USE_BLUEBERRY)
     include(mitkTestProjectTemplate)
   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()
 
 #-----------------------------------------------------------------------------
 # Compile Utilities and set-up MITK variables
 #-----------------------------------------------------------------------------
 
 include(mitkSetupVariables)
 
   #-----------------------------------------------------------------------------
   # Cleanup
   #-----------------------------------------------------------------------------
 
   file(GLOB _MODULES_CONF_FILES ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME}/*.cmake)
   if(_MODULES_CONF_FILES)
     file(REMOVE ${_MODULES_CONF_FILES})
   endif()
 
 add_subdirectory(Utilities)
 
 if(MITK_USE_BLUEBERRY)
 
   # We need to hack a little bit because MITK applications may need
   # to enable certain BlueBerry plug-ins. However, these plug-ins
   # are validated separately from the MITK plug-ins and know nothing
   # about potential MITK plug-in dependencies of the applications. Hence
   # we cannot pass the MITK application list to the BlueBerry
   # ctkMacroSetupPlugins call but need to extract the BlueBerry dependencies
   # from the applications and set them explicitly.
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
 
   foreach(mitk_app ${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)
     # check if the application is enabled and if target_libraries.cmake exists
     if((${option_name} OR MITK_BUILD_ALL_APPS) AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake")
       include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake")
       foreach(_target_dep ${target_libraries})
         if(_target_dep MATCHES org_blueberry_)
           string(REPLACE _ . _app_bb_dep ${_target_dep})
           # explicitly set the build option for the BlueBerry plug-in
           set(BLUEBERRY_BUILD_${_app_bb_dep} ON CACHE BOOL "Build the ${_app_bb_dep} plug-in")
         endif()
       endforeach()
     endif()
   endforeach()
 
   set(mbilog_DIR "${mbilog_BINARY_DIR}")
 
   if(MITK_BUILD_ALL_PLUGINS)
     set(BLUEBERRY_BUILD_ALL_PLUGINS ON)
   endif()
 
   add_subdirectory(BlueBerry)
 
   set(BlueBerry_DIR ${CMAKE_CURRENT_BINARY_DIR}/BlueBerry
       CACHE PATH "The directory containing a CMake configuration file for BlueBerry" FORCE)
 
   include(mitkMacroCreateCTKPlugin)
 
 endif()
 
 #-----------------------------------------------------------------------------
 # Set C/CXX Flags for MITK code
 #-----------------------------------------------------------------------------
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MITK_CXX_FLAGS_RELEASE}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MITK_C_FLAGS}")
 
 if(MITK_USE_QT)
   add_definitions(-DQWT_DLL)
 endif()
 
 #-----------------------------------------------------------------------------
 # Add custom targets representing CDash subprojects
 #-----------------------------------------------------------------------------
 
 foreach(subproject ${CTEST_PROJECT_SUBPROJECTS})
   if(NOT TARGET ${subproject} AND NOT subproject MATCHES "Unlabeled")
     add_custom_target(${subproject})
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 link_directories(${MITK_LINK_DIRECTORIES})
 
 add_subdirectory(Core)
 add_subdirectory(Modules)
 
 if(MITK_USE_BLUEBERRY)
 
   find_package(BlueBerry REQUIRED)
 
   set(MITK_DEFAULT_SUBPROJECTS MITK-Plugins)
 
   # Plug-in testing (needs some work to be enabled again)
   if(BUILD_TESTING)
     include(berryTestingHelpers)
 
     set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp")
     get_target_property(_is_macosx_bundle CoreApp MACOSX_BUNDLE)
     if(APPLE AND _is_macosx_bundle)
       set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.app/Contents/MacOS/CoreApp")
     endif()
 
     set(BLUEBERRY_TEST_APP_ID "org.mitk.qt.coreapplication")
   endif()
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PluginList.cmake")
   set(mitk_plugins_fullpath )
   foreach(mitk_plugin ${MITK_EXT_PLUGINS})
     list(APPEND mitk_plugins_fullpath Plugins/${mitk_plugin})
   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() 
 
   # 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 OUTPUT_VARIABLE ${varname})
   endmacro()
 
   # Get infos about application directories and build options
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
   set(mitk_apps_fullpath )
   foreach(mitk_app ${MITK_APPS})
     list(APPEND mitk_apps_fullpath "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${mitk_app}")
   endforeach()
 
   ctkMacroSetupPlugins(${mitk_plugins_fullpath}
                        BUILD_OPTION_PREFIX MITK_BUILD_
                        APPS ${mitk_apps_fullpath}
                        BUILD_ALL ${MITK_BUILD_ALL_PLUGINS}
                        COMPACT_OPTIONS)
 
   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()
 
 # Construct a list of paths containing runtime directories
 # for MITK applications on Windows
 set(MITK_RUNTIME_PATH 
     "${VTK_LIBRARY_DIRS}/%VS_BUILD_TYPE%;${ITK_LIBRARY_DIRS}/%VS_BUILD_TYPE%;${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/%VS_BUILD_TYPE%"
     )
 
 if(QT4_FOUND)
   set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${QT_LIBRARY_DIR}/../bin")
 endif()
 
 if(MITK_USE_BLUEBERRY)
   set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CTK_RUNTIME_LIBRARY_DIRS}/%VS_BUILD_TYPE%")
   if(DEFINED CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY)
     if(IS_ABSOLUTE "${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
       set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}/%VS_BUILD_TYPE%")
     else()
       set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}/%VS_BUILD_TYPE%")
     endif()
   else()
     set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins/%VS_BUILD_TYPE%")
   endif()
 endif()
 
 if(GDCM_DIR)
   set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${GDCM_DIR}/bin/%VS_BUILD_TYPE%")
 endif()
 
 if(OpenCV_DIR)
   set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${OpenCV_DIR}/bin/%VS_BUILD_TYPE%")
 endif()
 
 # DCMTK is statically build
 #if(DCMTK_DIR)
 #  set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${DCMTK_DIR}/bin/%VS_BUILD_TYPE%")
 #endif()
 
 if(MITK_USE_Boost AND MITK_USE_Boost_LIBRARIES AND NOT MITK_USE_SYSTEM_Boost)
   set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${Boost_LIBRARY_DIRS}")
 endif()
 
 #-----------------------------------------------------------------------------
 # Python Wrapping
 #-----------------------------------------------------------------------------
 
 set(MITK_WRAPPING_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Wrapping)
 set(MITK_WRAPPING_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Wrapping)
 option(MITK_USE_Python "Build cswig Python wrapper support (requires CableSwig)." OFF)
 if(MITK_USE_Python)
   add_subdirectory(Wrapping)
 endif()
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Documentation)
 
 #-----------------------------------------------------------------------------
 # Installation
 #-----------------------------------------------------------------------------
 
 
 # set MITK cpack variables
 # These are the default variables, which can be overwritten ( see below )
 include(mitkSetupCPack)
 
 set(use_default_config ON)
 
 # MITK_APPS is set in Applications/AppList.cmake (included somewhere above
 # if MITK_USE_BLUEBERRY is set to ON).
 if(MITK_APPS)
 
   set(activated_apps_no 0)
   list(LENGTH MITK_APPS app_count)
 
   # Check how many apps have been enabled
   # If more than one app has been activated, the we use the 
   # default CPack configuration. Otherwise that apps configuration
   # will be used, if present.
   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)
     # check if the application is enabled
     if(${option_name} OR MITK_BUILD_ALL_APPS)
       MATH(EXPR activated_apps_no "${activated_apps_no} + 1")
     endif()
   endforeach()
 
   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 ${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)
     # 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 "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake")
           include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake")
         endif()
 
         if(EXISTS "${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in")
           set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/Applications/${target_dir}/CPackConfig.cmake")
           configure_file(${PROJECT_SOURCE_DIR}/Applications/${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 "${target_dir}")
     endif()
   endforeach()
 
 endif()
 
 # 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
 #-----------------------------------------------------------------------------
 
 set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake")
 file(REMOVE ${MITK_EXPORTS_FILE})
 
 if(MITK_USE_BLUEBERRY)
   # This is for installation support of external projects depending on
   # MITK plugins. The export file should not be used for linking to MITK
   # libraries without using LINK_DIRECTORIES, since the exports are incomplete
   # yet(depending libraries are not exported).
   if(MITK_PLUGIN_LIBRARIES)
     export(TARGETS ${MITK_PLUGIN_LIBRARIES}
            APPEND
            FILE ${MITK_EXPORTS_FILE})
   endif()
 endif()
 
 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)
 
 set(VISIBILITY_AVAILABLE 0)
 set(visibility_test_flag "")
 mitkFunctionCheckCompilerFlags("-fvisibility=hidden" visibility_test_flag)
 if(visibility_test_flag)
   # The compiler understands -fvisiblity=hidden (probably gcc >= 4 or Clang)
   set(VISIBILITY_AVAILABLE 1)
 endif()
 configure_file(mitkExportMacros.h.in ${MITK_BINARY_DIR}/mitkExportMacros.h)
 
 configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h)
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 
 set(VECMATH_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/vecmath)
 set(IPFUNC_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipFunc)
 set(UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities)
 
 file(GLOB _MODULES_CONF_FILES RELATIVE ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME} ${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME}/*.cmake)
 set(MITK_MODULE_NAMES)
 foreach(_module ${_MODULES_CONF_FILES})
   string(REPLACE Config.cmake "" _module_name ${_module})
   list(APPEND MITK_MODULE_NAMES ${_module_name})
 endforeach() 
 
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY)
 
 # If we are under Windows, create two batch files which correctly
 # set up the environment for the application and for Visual Studio
 if(WIN32)
   include(mitkFunctionCreateWindowsBatchScript)
   
   set(VS_SOLUTION_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}.sln")
   foreach(VS_BUILD_TYPE debug release)
     mitkFunctionCreateWindowsBatchScript("${MITK_SOURCE_DIR}/CMake/StartVS.bat.in"
       ${PROJECT_BINARY_DIR}/StartVS_${VS_BUILD_TYPE}.bat
       ${VS_BUILD_TYPE})
   endforeach()
 endif(WIN32)
 
 
 #-----------------------------------------------------------------------------
 # MITK Applications
 #-----------------------------------------------------------------------------
 
 # This must come after MITKConfig.h was generated, since applications
 # might do a find_package(MITK REQUIRED).
 add_subdirectory(Applications)
 
 #-----------------------------------------------------------------------------
 # 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()
 
diff --git a/Core/Code/CppMicroServices/src/service/usServiceInterface.h b/Core/Code/CppMicroServices/src/service/usServiceInterface.h
index de734d2b95..34bc674a8c 100644
--- a/Core/Code/CppMicroServices/src/service/usServiceInterface.h
+++ b/Core/Code/CppMicroServices/src/service/usServiceInterface.h
@@ -1,55 +1,55 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   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.
 
 =============================================================================*/
 
 
 #ifndef USSERVICEINTERFACE_H
 #define USSERVICEINTERFACE_H
 
 #include <usConfig.h>
 
 template<class T> inline const char* us_service_interface_iid()
 { return 0; }
 
-#if defined(QT_DEBUG) || defined(QT_NODEBUG)
+#if defined(QT_DEBUG) || defined(QT_NO_DEBUG)
 #include <qobject.h>
 
 #define US_DECLARE_SERVICE_INTERFACE(IFace, IId)                                 \
   template<> inline const char* qobject_interface_iid<IFace *>()                 \
   { return IId; }                                                                \
   template<> inline const char* us_service_interface_iid<IFace *>()              \
   { return IId; }                                                                \
   template<> inline IFace *qobject_cast<IFace *>(QObject *object)                \
   { return dynamic_cast<IFace*>(reinterpret_cast<US_BASECLASS_NAME *>((object ? object->qt_metacast(IId) : 0))); } \
   template<> inline IFace *qobject_cast<IFace *>(const QObject *object)          \
   { return dynamic_cast<IFace*>(reinterpret_cast<US_BASECLASS_NAME *>((object ? const_cast<QObject *>(object)->qt_metacast(IId) : 0))); }
 
 #else
 
 #define US_DECLARE_SERVICE_INTERFACE(IFace, IId)                                 \
   template<> inline const char* us_service_interface_iid<IFace *>()              \
   { return IId; }                                                                \
 
 #endif
 
 template<class T> inline const char* us_service_impl_name(T* /*impl*/)
 { return "(unknown implementation)"; }
 
 #endif // USSERVICEINTERFACE_H
diff --git a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
index 5afe426f4f..8ff925486c 100644
--- a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
+++ b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
@@ -1,1008 +1,1008 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //MITK
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkDataNode.h>
 #include <mitkDataNodeFactory.h>
 #include <mitkImageSliceSelector.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkProperties.h>
 #include <mitkResliceMethodProperty.h>
 #include <mitkTimeSlicedGeometry.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 #include <mitkPixelType.h>
 //#include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include "mitkImageStatisticsHolder.h"
 
 //MITK Rendering
 #include "mitkImageVtkMapper2D.h"
 #include "vtkMitkThickSlicesFilter.h"
 #include "vtkMitkApplyLevelWindowToRGBFilter.h"
 
 //VTK
 #include <vtkProperty.h>
 #include <vtkTransform.h>
 #include <vtkMatrix4x4.h>
 #include <vtkLookupTable.h>
 #include <vtkImageData.h>
 #include <vtkPoints.h>
 #include <vtkGeneralTransform.h>
 #include <vtkImageReslice.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkPlaneSource.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkTexture.h>
 #include <vtkCellArray.h>
 #include <vtkCamera.h>
 #include <vtkColorTransferFunction.h>
 
 //ITK
 #include <itkRGBAPixel.h>
 
 mitk::ImageVtkMapper2D::ImageVtkMapper2D()
 {
 }
 
 mitk::ImageVtkMapper2D::~ImageVtkMapper2D()
 {
   //The 3D RW Mapper (Geometry2DDataVtkMapper3D) 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, vtkFloatingPointType 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.
   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 QBalls 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 * >( this->GetData() );
 }
 
 vtkProp* mitk::ImageVtkMapper2D::GetVtkProp(mitk::BaseRenderer* renderer)
 {  
   //return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Actor;
 }
 
 void mitk::ImageVtkMapper2D::MitkRenderOverlay(BaseRenderer* renderer)
 {
   if ( this->IsVisible(renderer)==false )
     return;
   if ( this->GetVtkProp(renderer)->GetVisibility() )
   {
     this->GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer());
   }
 }
 
 void mitk::ImageVtkMapper2D::MitkRenderOpaqueGeometry(BaseRenderer* renderer)
 {
   if ( this->IsVisible( renderer )==false )
     return;
   if ( this->GetVtkProp(renderer)->GetVisibility() )
   {
     this->GetVtkProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() );
   }
 }
 
 void mitk::ImageVtkMapper2D::MitkRenderTranslucentGeometry(BaseRenderer* renderer)
 {
   if ( this->IsVisible(renderer)==false )
     return;
   if ( this->GetVtkProp(renderer)->GetVisibility() )
   {
     this->GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer());
   }
 }
 
 void mitk::ImageVtkMapper2D::MitkRenderVolumetricGeometry(BaseRenderer* renderer)
 {
   if(IsVisible(renderer)==false)
     return;
   if ( GetVtkProp(renderer)->GetVisibility() )
   {
     this->GetVtkProp(renderer)->RenderVolumetricGeometry(renderer->GetVtkRenderer());
   }
 }
 
 void mitk::ImageVtkMapper2D::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 == NULL || input->IsInitialized() == false )
   {
     return;
   }
 
   //check if there is a valid worldGeometry
   const Geometry2D *worldGeometry = renderer->GetCurrentWorldGeometry2D();
   if( ( worldGeometry == NULL ) || ( !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() ) )
   {
     localStorage->m_Mapper->SetInput( 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->GetTimeSlicedGeometry()->GetGeometry3D( 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 != NULL )
     {
       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->GetCurrentWorldGeometry2DNode();
     if(dn)
     {
       ResliceMethodProperty *resliceMethodEnumProperty=0;
 
       if( dn->GetProperty( resliceMethodEnumProperty, "reslice.thickslices" ) && resliceMethodEnumProperty )
         thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
 
       IntProperty *intProperty=0;
       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";
     }
   }
 
 
   if(thickSlicesMode > 0)
   {  
     double dataZSpacing = 1.0;
 
     Vector3D normInIndex, normal;
     const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( worldGeometry );
     if ( planeGeometry != NULL ){
       normal = planeGeometry->GetNormal();
     }else{
       const mitk::AbstractTransformGeometry* abstractGeometry = dynamic_cast< const AbstractTransformGeometry * >(worldGeometry);
       if(abstractGeometry != NULL)
         normal = abstractGeometry->GetPlane()->GetNormal();
       else
         return; //no fitting geometry set
     }
     normal.Normalize();
 
     input->GetTimeSlicedGeometry()->GetGeometry3D( 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->SetInput( 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
   vtkFloatingPointType 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();
 
 
   //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
     {
       if ( input->GetPixelType().GetBpe() <= 8 )
       {
         //generate contours/outlines
         localStorage->m_OutlinePolyData = CreateOutlinePolyData(renderer);
 
         float binaryOutlineWidth(1.0);
         if ( datanode->GetFloatProperty( "outline width", binaryOutlineWidth, renderer ) )
         {
           localStorage->m_Actor->GetProperty()->SetLineWidth(binaryOutlineWidth);
         }
       }
       else
       {
         binaryOutline = false;
         this->ApplyLookuptable(renderer);
         MITK_WARN << "Type of all binary images should be (un)signed char. Outline does not work on other pixel types!";
       }
     }
     else //standard binary image
     {
       if(numberOfComponents != 1)
       {
         MITK_ERROR << "Rendering Error: Binary Images with more then 1 component are not supported!";
       }
     }
     this->ApplyLookuptable(renderer);
     //Interpret the values as binary values
     localStorage->m_Texture->MapColorScalarsThroughLookupTableOn();
   }
   else if( numberOfComponents == 1 ) //gray images
   {
     //Interpret the values as gray values
     localStorage->m_Texture->MapColorScalarsThroughLookupTableOn();
 
     this->ApplyLookuptable(renderer);
   }
   else if ( (numberOfComponents == 3) || (numberOfComponents == 4) ) //RBG(A) images
   {
     //Interpret the RGB(A) images values correctly
     localStorage->m_Texture->MapColorScalarsThroughLookupTableOff();
 
     this->ApplyLookuptable(renderer);
     this->ApplyRBGALevelWindow(renderer);
   }
   else
   {
     MITK_ERROR << "2D Reindering Error: Unknown number of components!!! Please report to rendering task force or check your data!";
   }
 
   this->ApplyColor( renderer );
   this->ApplyOpacity( renderer );
   this->TransformActor( renderer );
 
   //connect mapper with the data
   if(binary && binaryOutline) //connect the mapper with the polyData which contains the lines
   {
     //We need the contour for the binary oultine property as actor
     localStorage->m_Mapper->SetInput(localStorage->m_OutlinePolyData);
     localStorage->m_Actor->SetTexture(NULL); //no texture for contours
   }
   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);
   }
 
   // We have been modified => save this for next Update()
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::ImageVtkMapper2D::ApplyColor( mitk::BaseRenderer* renderer )
 {
   LocalStorage *localStorage = this->GetLocalStorage( renderer );
 
   // check for interpolation properties
   bool textureInterpolation = false;
   GetDataNode()->GetBoolProperty( "texture interpolation", textureInterpolation, renderer );
 
   //set the interpolation modus according to the property
   localStorage->m_Texture->SetInterpolate(textureInterpolation);
 
   bool useColor = true;
   this->GetDataNode()->GetBoolProperty( "use color", useColor, renderer );
   if( useColor )
   {
     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
       {
         GetColor( rgb, renderer );
       }
     }
     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
       {
         GetColor( rgb, renderer );
       }
     }
     if(!hover && !selected)
     {
       GetColor( rgb, renderer );
     }
 
     double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; //conversion to double for VTK
     localStorage->m_Actor->GetProperty()->SetColor(rgbConv);
   }
   else
   {
     //If the user defines a lut, we dont want to use the color and take white instead.
     localStorage->m_Actor->GetProperty()->SetColor(1.0, 1.0, 1.0);
   }
 }
 
 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
   GetOpacity( opacity, renderer );
   //set the opacity according to the properties
   localStorage->m_Actor->GetProperty()->SetOpacity(opacity);
 }
 
 void mitk::ImageVtkMapper2D::ApplyLookuptable( mitk::BaseRenderer* renderer )
 {
   bool binary = false;
   bool CTFcanBeApplied = false;
   this->GetDataNode()->GetBoolProperty( "binary", binary, renderer );
   LocalStorage* localStorage = this->GetLocalStorage(renderer);
 
   float blackOpacity = 0.0;
   bool isBinary = false;
   bool foundBinaryProperty = false;
 
   foundBinaryProperty = this->GetDataNode()->GetBoolProperty("binary", isBinary, renderer);
   if (foundBinaryProperty && !isBinary)
   {
     this->GetDataNode()->GetFloatProperty( "black opacity", blackOpacity, renderer);
   }
   localStorage->m_LookupTable->SetTableValue(0, 0.0, 0.0, 0.0, blackOpacity);
 
   //default lookuptable
   localStorage->m_Texture->SetLookupTable( localStorage->m_LookupTable );
 
   if(binary)
   {
     //default lookuptable for binary images
     localStorage->m_Texture->GetLookupTable()->SetRange(0.0, 1.0);
   }
   else
   {
     bool useColor = true;
     this->GetDataNode()->GetBoolProperty( "use color", useColor, renderer );
     if((!useColor))
     {
       //BEGIN PROPERTY user-defined lut
       //currently we do not allow a lookuptable if it is a binary image
       // If lookup table use is requested...
       mitk::LookupTableProperty::Pointer LookupTableProp;
       LookupTableProp = dynamic_cast<mitk::LookupTableProperty*>
         (this->GetDataNode()->GetProperty("LookupTable"));
       //...check if there is a lookuptable provided by the user
       if ( LookupTableProp.IsNotNull() )
       {
         // If lookup table use is requested and supplied by the user:
         // only update the lut, when the properties have changed...
         if( LookupTableProp->GetLookupTable()->GetMTime()
           <= this->GetDataNode()->GetPropertyList()->GetMTime() )
         {
           LookupTableProp->GetLookupTable()->ChangeOpacityForAll( LookupTableProp->GetLookupTable()->GetVtkLookupTable()->GetAlpha()*localStorage->m_Actor->GetProperty()->GetOpacity() );
           LookupTableProp->GetLookupTable()->ChangeOpacity(0, blackOpacity);
         }
         //we use the user-defined lookuptable
         localStorage->m_Texture->SetLookupTable( LookupTableProp->GetLookupTable()->GetVtkLookupTable() );
       }
       else
       {
         CTFcanBeApplied = true;
       }
     }//END PROPERTY user-defined lut
     LevelWindow levelWindow;
     this->GetLevelWindow( levelWindow, renderer );
     //set up the lookuptable with the level window range
     localStorage->m_Texture->GetLookupTable()->SetRange( levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound() );
   }
   //the color function can be applied if the user does not want to use color
   //and does not provide a lookuptable
   if(CTFcanBeApplied)
   {
     ApplyColorTransferFunction(renderer);
   }
   localStorage->m_Texture->SetInput( localStorage->m_ReslicedImage );
 }
 
 void mitk::ImageVtkMapper2D::ApplyColorTransferFunction(mitk::BaseRenderer* renderer)
 {
   mitk::TransferFunctionProperty::Pointer transferFunctionProperty =
     dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("Image Rendering.Transfer Function",renderer ));
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
   if(transferFunctionProperty.IsNotNull())
   {
     localStorage->m_Texture->SetLookupTable(transferFunctionProperty->GetValue()->GetColorTransferFunction());
   }
   else
   {
     MITK_WARN << "Neither a lookuptable nor a transfer function is set and use color is off.";
   }
 }
 
 
 
 void mitk::ImageVtkMapper2D::ApplyRBGALevelWindow( mitk::BaseRenderer* renderer )
 {
   LocalStorage* localStorage = this->GetLocalStorage( renderer );
   //pass the LuT to the RBG filter
   localStorage->m_LevelWindowToRGBFilterObject->SetLookupTable(localStorage->m_Texture->GetLookupTable());
   mitk::LevelWindow opacLevelWindow;
   if( this->GetLevelWindow( opacLevelWindow, renderer, "opaclevelwindow" ) )
   {//pass the opaque level window to the filter
     localStorage->m_LevelWindowToRGBFilterObject->SetMinOpacity(opacLevelWindow.GetLowerWindowBound());
     localStorage->m_LevelWindowToRGBFilterObject->SetMaxOpacity(opacLevelWindow.GetUpperWindowBound());
   }
   else
   {//no opaque level window
     localStorage->m_LevelWindowToRGBFilterObject->SetMinOpacity(0.0);
     localStorage->m_LevelWindowToRGBFilterObject->SetMaxOpacity(255.0);
   }
   localStorage->m_LevelWindowToRGBFilterObject->SetInput(localStorage->m_ReslicedImage);
   //connect the texture with the output of the RGB filter
   localStorage->m_Texture->SetInputConnection(localStorage->m_LevelWindowToRGBFilterObject->GetOutputPort());
 }
 
 void mitk::ImageVtkMapper2D::Update(mitk::BaseRenderer* renderer)
 {
   if ( !this->IsVisible( renderer ) )
   {
     return;
   }
 
   mitk::Image* data  = const_cast<mitk::Image *>( this->GetInput() );
   if ( data == NULL )
   {
     return;
   }
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep( renderer );
 
   // Check if time step is valid
   const TimeSlicedGeometry *dataTimeGeometry = data->GetTimeSlicedGeometry();
   if ( ( dataTimeGeometry == NULL )
     || ( dataTimeGeometry->GetTimeSteps() == 0 )
     || ( !dataTimeGeometry->IsValidTime( 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->GetCurrentWorldGeometry2DUpdateTime()) //was the geometry modified?
     || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2D()->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::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( "use color", mitk::BoolProperty::New( true ), renderer, overwrite );
   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 );
   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( mitk::DataNodeFactory::m_TextureInterpolationActive ) );  // 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 ) );
 
   std::string modality;
   if ( node->GetStringProperty( "dicom.series.Modality", modality ) )
   {
     // modality provided by DICOM or other reader
     if ( modality == "PT") // NOT a typo, PT is the abbreviation for PET used in DICOM
     {
       node->SetProperty( "use color", mitk::BoolProperty::New( false ), renderer );
       node->SetProperty( "opacity", mitk::FloatProperty::New( 0.5 ), renderer );
     }
   }
 
   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 ( 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( "black opacity", mitk::FloatProperty::New( 0.0 ), 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)==NULL))
     {
       /* initialize level/window from DICOM tags */
       std::string sLevel;
       std::string sWindow;
-      if (   node->GetStringProperty( "dicom.voilut.WindowCenter", sLevel )
-        && node->GetStringProperty( "dicom.voilut.WindowWidth", sWindow ) )
+      if ( image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowCenter", sLevel )
+        && image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowWidth", sWindow ) )
       {
         float level = atof( sLevel.c_str() );
         float window = atof( sWindow.c_str() );
 
         mitk::LevelWindow contrast;
         std::string sSmallestPixelValueInSeries;
         std::string sLargestPixelValueInSeries;
 
-        if (    node->GetStringProperty( "dicom.series.SmallestPixelValueInSeries", sSmallestPixelValueInSeries )
-          && node->GetStringProperty( "dicom.series.LargestPixelValueInSeries", sLargestPixelValueInSeries ) )
+        if ( image->GetPropertyList()->GetStringProperty( "dicom.series.SmallestPixelValueInSeries", sSmallestPixelValueInSeries )
+          && image->GetPropertyList()->GetStringProperty( "dicom.series.LargestPixelValueInSeries", 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)==NULL))
        && (image->GetPixelType().GetPixelTypeId() == itk::ImageIOBase::RGBA)
        && (image->GetPixelType().GetTypeId() == typeid( unsigned char)) )
     {
       mitk::LevelWindow opaclevwin;
       opaclevwin.SetRangeMinMax(0,255);
       opaclevwin.SetWindowBounds(0,255);
       mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin);
       node->SetProperty( "opaclevelwindow", prop, renderer );
     }
     if((overwrite) || (node->GetProperty("LookupTable", renderer)==NULL))
     {
       // add a default rainbow lookup table for color mapping
       mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
       vtkLookupTable* vtkLut = mitkLut->GetVtkLookupTable();
       vtkLut->SetHueRange(0.6667, 0.0);
       vtkLut->SetTableRange(0.0, 20.0);
       vtkLut->Build();
       mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
       mitkLutProp->SetLookupTable(mitkLut);
       node->SetProperty( "LookupTable", mitkLutProp );
     }
   }
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 mitk::ImageVtkMapper2D::LocalStorage* mitk::ImageVtkMapper2D::GetLocalStorage(mitk::BaseRenderer* renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 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
   char* currentPixel;
 
 
   //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
 
   while (y <= yMax) 
   { 
     currentPixel = static_cast<char*>(localStorage->m_ReslicedImage->GetScalarPointer(x, y, 0));
 
     //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++;
     }
   }//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
   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)
   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);
 }
 
 bool mitk::ImageVtkMapper2D::RenderingGeometryIntersectsImage( const Geometry2D* renderingGeometry, SlicedGeometry3D* imageGeometry )
 {
   // if either one of the two geometries is NULL we return true 
   // for safety reasons
   if ( renderingGeometry == NULL || imageGeometry == NULL )
     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()
 {
   //Do as much actions as possible in here to avoid double executions.
   m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
   m_Texture = vtkSmartPointer<vtkTexture>::New();
   m_LookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_Actor = vtkSmartPointer<vtkActor>::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();
 
   //built a default lookuptable
   m_LookupTable->SetRampToLinear();
   m_LookupTable->SetSaturationRange( 0.0, 0.0 );
   m_LookupTable->SetHueRange( 0.0, 0.0 );
   m_LookupTable->SetValueRange( 0.0, 1.0 );
   m_LookupTable->Build();
 
   //do not repeat the texture (the image)
   m_Texture->RepeatOff();
 
   //set the mapper for the actor
   m_Actor->SetMapper(m_Mapper);
 
   //filter for RGB(A) images
   m_LevelWindowToRGBFilterObject = new vtkMitkApplyLevelWindowToRGBFilter();
 }
diff --git a/Core/Code/Rendering/mitkVtkPropRenderer.cpp b/Core/Code/Rendering/mitkVtkPropRenderer.cpp
index 9b88069173..b37d19fe38 100644
--- a/Core/Code/Rendering/mitkVtkPropRenderer.cpp
+++ b/Core/Code/Rendering/mitkVtkPropRenderer.cpp
@@ -1,936 +1,937 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "mitkVtkPropRenderer.h"
 
 // MAPPERS
 #include "mitkMapper.h"
 #include "mitkImageVtkMapper2D.h"
 #include "mitkVtkMapper2D.h"
 #include "mitkVtkMapper3D.h"
 #include "mitkGeometry2DDataVtkMapper3D.h"
 #include "mitkPointSetGLMapper2D.h"
 
 #include "mitkImageSliceSelector.h"
 #include "mitkRenderingManager.h"
 #include "mitkGL.h"
 #include "mitkGeometry3D.h"
 #include "mitkDisplayGeometry.h"
 #include "mitkLevelWindow.h"
 #include "mitkCameraController.h"
 #include "mitkVtkInteractorCameraController.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 #include "mitkSurface.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkVtkInteractorStyle.h"
 
 // VTK
 #include <vtkRenderer.h>
 #include <vtkRendererCollection.h>
 #include <vtkLight.h>
 #include <vtkLightKit.h>
 #include <vtkRenderWindow.h>
 #include <vtkLinearTransform.h>
 #include <vtkCamera.h>
 #include <vtkWorldPointPicker.h>
 #include <vtkPointPicker.h>
 #include <vtkCellPicker.h>
 #include <vtkTextActor.h>
 #include <vtkTextProperty.h>
 #include <vtkProp.h>
 #include <vtkAssemblyPath.h>
 #include <vtkAssemblyNode.h>
 #include <vtkMapper.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
 #include <vtkInteractorStyleTrackballCamera.h>
 
 
 mitk::VtkPropRenderer::VtkPropRenderer( const char* name, vtkRenderWindow * renWin, mitk::RenderingManager* rm )
   : BaseRenderer(name,renWin, rm), 
   m_VtkMapperPresent(false), 
   m_NewRenderer(true),
   m_CameraInitializedForMapperID(0)
 {
   didCount=false;
 
   m_WorldPointPicker = vtkWorldPointPicker::New();
 
   m_PointPicker = vtkPointPicker::New();
   m_PointPicker->SetTolerance( 0.0025 );
 
   m_CellPicker = vtkCellPicker::New();
   m_CellPicker->SetTolerance( 0.0025 );
 
   mitk::Geometry2DDataVtkMapper3D::Pointer geometryMapper = mitk::Geometry2DDataVtkMapper3D::New();
   m_CurrentWorldGeometry2DMapper = geometryMapper;
   m_CurrentWorldGeometry2DNode->SetMapper(2, geometryMapper);
 
   m_LightKit = vtkLightKit::New();
   m_LightKit->AddLightsToRenderer(m_VtkRenderer);
   m_PickingMode = WorldPointPicking;
 
   m_TextRenderer = vtkRenderer::New();
   m_TextRenderer->SetRenderWindow(renWin);
   m_TextRenderer->SetInteractive(0);
   m_TextRenderer->SetErase(0);
 }
 
 /*!
 \brief Destructs the VtkPropRenderer.
 */
 mitk::VtkPropRenderer::~VtkPropRenderer()
 {
   // Workaround for GLDisplayList Bug
   {
     m_MapperID=0;
     checkState();
   }
 
   if (m_LightKit != NULL)
     m_LightKit->Delete();
 
   if (m_VtkRenderer!=NULL)
   {
     m_CameraController = NULL;
 
     m_VtkRenderer->Delete();
 
     m_VtkRenderer = NULL;
   }
   else
     m_CameraController = NULL;
 
   if (m_WorldPointPicker != NULL)
     m_WorldPointPicker->Delete();
   if (m_PointPicker != NULL)
     m_PointPicker->Delete();
   if (m_CellPicker != NULL)
     m_CellPicker->Delete();
   if (m_TextRenderer != NULL)
     m_TextRenderer->Delete();
 }
 
 
 void mitk::VtkPropRenderer::SetDataStorage(  mitk::DataStorage* storage  )
 {
   if ( storage == NULL )
     return;
 
   BaseRenderer::SetDataStorage(storage);
 
   static_cast<mitk::Geometry2DDataVtkMapper3D*>(m_CurrentWorldGeometry2DMapper.GetPointer())->SetDataStorageForTexture( m_DataStorage.GetPointer() );
 
   // Compute the geometry from the current data tree bounds and set it as world geometry
   this->SetWorldGeometryToDataStorageBounds();
 }
 
 
 bool mitk::VtkPropRenderer::SetWorldGeometryToDataStorageBounds()
 {
   if ( m_DataStorage.IsNull() )
     return false;
 
   //initialize world geometry
   mitk::TimeSlicedGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D( NULL, "includeInBoundingBox" );
 
   if ( geometry.IsNull() )
     return false;
 
   this->SetWorldGeometry(geometry);
   //this->GetDisplayGeometry()->SetSizeInDisplayUnits( this->m_TextRenderer->GetRenderWindow()->GetSize()[0], this->m_TextRenderer->GetRenderWindow()->GetSize()[1] );
   this->GetDisplayGeometry()->Fit();
   this->GetVtkRenderer()->ResetCamera();
   this->Modified();
   return true;
 }
 
 
 /*!
 \brief 
 
 Called by the vtkMitkRenderProp in order to start MITK rendering process.
 */
 int mitk::VtkPropRenderer::Render(mitk::VtkPropRenderer::RenderType type)
 {
 
   // Do we have objects to render?
   if ( this->GetEmptyWorldGeometry()) 
     return 0;
 
   if ( m_DataStorage.IsNull())
     return 0;
 
   // Update mappers and prepare mapper queue
   if (type == VtkPropRenderer::Opaque)
     this->PrepareMapperQueue();
   
   //go through the generated list and let the sorted mappers paint
   bool lastVtkBased = true;
   //bool sthVtkBased = false;
   
   for(MappersMapType::iterator it = m_MappersMap.begin(); it != m_MappersMap.end(); it++)
   {
     Mapper * mapper = (*it).second;
     if((mapper->IsVtkBased() == true) )
     {
       //sthVtkBased = true;
       mitk::VtkMapper3D::Pointer vtkMapper = dynamic_cast<mitk::VtkMapper3D*>(mapper);
       if(vtkMapper)
       {
         vtkMapper->GetVtkProp(this)->SetAllocatedRenderTime(5000,GetVtkRenderer()); //B/ ToDo: rendering time calculation
         //vtkMapper->GetVtkProp(this)->PokeMatrix(NULL); //B/ ToDo ??: VtkUserTransform
       }
       if(lastVtkBased == false)
       {
         Disable2DOpenGL();
         lastVtkBased = true;
       }
     }
     else
       if((mapper->IsVtkBased() == false) && (lastVtkBased == true))
       {
       Enable2DOpenGL();
       lastVtkBased = false;
     }
 
     //Workarround for bug GL_TEXTURE_2D (bug #8188)
     GLboolean mode;
     GLenum bit = GL_TEXTURE_2D;
     GLfloat lineWidth;
     glGetFloatv(GL_LINE_WIDTH, &lineWidth);
     glGetBooleanv(bit, &mode);
 
     switch(type)
     {
     case mitk::VtkPropRenderer::Opaque: mapper->MitkRenderOpaqueGeometry(this); break;
     case mitk::VtkPropRenderer::Translucent: mapper->MitkRenderTranslucentGeometry(this); break;
     case mitk::VtkPropRenderer::Overlay:       mapper->MitkRenderOverlay(this); break;
     case mitk::VtkPropRenderer::Volumetric:    mapper->MitkRenderVolumetricGeometry(this); break;
     }
     if(mode)
       glEnable(bit);
     else
       glDisable(bit);
 
     glLineWidth(lineWidth);
     //end Workarround for bug GL_TEXTURE_2D (bug #8188)
 
   }
   
   if (lastVtkBased == false)
     Disable2DOpenGL();
 
   // Render text
   if (type == VtkPropRenderer::Overlay)
   {
     if (m_TextCollection.size() > 0)
     {
       for (TextMapType::iterator it = m_TextCollection.begin(); it != m_TextCollection.end() ; it++)
         m_TextRenderer->AddViewProp((*it).second);
       m_TextRenderer->Render();
     }
   }
   return 1;
 }
 
 /*!
 \brief PrepareMapperQueue iterates the datatree
 
 PrepareMapperQueue iterates the datatree in order to find mappers which shall be rendered. Also, it sortes the mappers wrt to their layer.
 */
 void mitk::VtkPropRenderer::PrepareMapperQueue()
 {
   // variable for counting LOD-enabled mappers
   m_NumberOfVisibleLODEnabledMappers = 0;
 
   // Do we have to update the mappers ?
   if ( m_LastUpdateTime < GetMTime() || m_LastUpdateTime < GetDisplayGeometry()->GetMTime() ) {
     Update();
   }
   else if (m_MapperID>=1 && m_MapperID < 6)
     Update();
 
   // remove all text properties before mappers will add new ones
   m_TextRenderer->RemoveAllViewProps();
 
   for ( unsigned int i=0; i<m_TextCollection.size(); i++ )
   {
     m_TextCollection[i]->Delete();
   }
   m_TextCollection.clear();
 
   // clear priority_queue
   m_MappersMap.clear();
 
   int mapperNo = 0;
 
   //DataStorage
   if( m_DataStorage.IsNull() )
     return;
 
   DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
 
   for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();  it != allObjects->End(); ++it)
   {
     DataNode::Pointer node = it->Value();
     if ( node.IsNull() )
       continue;
     mitk::Mapper::Pointer mapper = node->GetMapper(m_MapperID);
 
     if ( mapper.IsNull() )
       continue;
 
     // The information about LOD-enabled mappers is required by RenderingManager
     if ( mapper->IsLODEnabled( this ) && mapper->IsVisible( this ) )
     {
       ++m_NumberOfVisibleLODEnabledMappers;
     }
     // mapper without a layer property get layer number 1
     int layer = 1;
     node->GetIntProperty("layer", layer, this);
     int nr = (layer<<16) + mapperNo;
     m_MappersMap.insert( std::pair< int, Mapper * >( nr, mapper ) );
     mapperNo++;
   }  
 }
 
 /*!
 \brief 
 
 Enable2DOpenGL() and Disable2DOpenGL() are used to switch between 2D rendering (orthographic projection) and 3D rendering (perspective projection)
 */
 void mitk::VtkPropRenderer::Enable2DOpenGL()
 {
   GLint iViewport[4];  
 
   // Get a copy of the viewport  
   glGetIntegerv( GL_VIEWPORT, iViewport );  
 
   // Save a copy of the projection matrix so that we can restore it  
   // when it's time to do 3D rendering again.  
   glMatrixMode( GL_PROJECTION );  
   glPushMatrix();
   glLoadIdentity();  
 
   // Set up the orthographic projection  
   glOrtho( 
       iViewport[0], iViewport[0]+iViewport[2],
       iViewport[1], iViewport[1]+iViewport[3],
       -1.0, 1.0
       );
   glMatrixMode( GL_MODELVIEW );  
   glPushMatrix();  
   glLoadIdentity();
 
   // Make sure depth testing and lighting are disabled for 2D rendering until  
   // we are finished rendering in 2D  
   glPushAttrib( GL_DEPTH_BUFFER_BIT | GL_LIGHTING_BIT );
   glDisable( GL_DEPTH_TEST );  
   glDisable( GL_LIGHTING );
 }
 
 /*!
 \brief Initialize the VtkPropRenderer
 
 Enable2DOpenGL() and Disable2DOpenGL() are used to switch between 2D rendering (orthographic projection) and 3D rendering (perspective projection)
 */
 void mitk::VtkPropRenderer::Disable2DOpenGL()
 {
   glPopAttrib();
   glMatrixMode( GL_PROJECTION );  
   glPopMatrix();  
   glMatrixMode( GL_MODELVIEW );  
   glPopMatrix(); 
 }
 
 void mitk::VtkPropRenderer::Update(mitk::DataNode* datatreenode)
 {
   if(datatreenode!=NULL)
   {
     mitk::Mapper::Pointer mapper = datatreenode->GetMapper(m_MapperID);
     if(mapper.IsNotNull())
     {
       Mapper2D* mapper2d=dynamic_cast<Mapper2D*>(mapper.GetPointer());
       if(mapper2d != NULL)
       {
         if(GetDisplayGeometry()->IsValid())
         {
           VtkMapper2D* vtkmapper2d=dynamic_cast<VtkMapper2D*>(mapper.GetPointer());
           if(vtkmapper2d != NULL)
           {
             vtkmapper2d->Update(this);
             m_VtkMapperPresent=true;
           }
           else
             mapper2d->Update(this);
         }
       }
       else
       {
         VtkMapper3D* vtkmapper3d=dynamic_cast<VtkMapper3D*>(mapper.GetPointer());
         if(vtkmapper3d != NULL)
         {
           vtkmapper3d->Update(this);
           vtkmapper3d->UpdateVtkTransform(this);
           m_VtkMapperPresent=true;
         }
       }
     }
   }
 }
 
 
 void mitk::VtkPropRenderer::Update()
 {
   if( m_DataStorage.IsNull() )
     return;
 
   m_VtkMapperPresent = false;
   mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetAll();
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
     Update(it->Value());
 
   Modified();
   m_LastUpdateTime = GetMTime();
 }
 
 
 /*!
 \brief
 
 This method is called from the two Constructors
 */
 void mitk::VtkPropRenderer::InitRenderer(vtkRenderWindow* renderWindow)
 {
   BaseRenderer::InitRenderer(renderWindow);
 
   if(renderWindow == NULL)
   {
     m_InitNeeded = false;
     m_ResizeNeeded = false;
     return;
   }
 
   m_InitNeeded = true;
   m_ResizeNeeded = true;
 
   m_LastUpdateTime = 0;
 
 }
 
 
 /*!
 \brief Resize the OpenGL Window
 */
 void mitk::VtkPropRenderer::Resize(int w, int h)
 {
   BaseRenderer::Resize(w, h);
   m_RenderingManager->RequestUpdate(this->GetRenderWindow());
 }
 
 
 void mitk::VtkPropRenderer::InitSize(int w, int h)
 {
   m_RenderWindow->SetSize(w,h);
   Superclass::InitSize(w, h);
   Modified();
   Update();
   if(m_VtkRenderer!=NULL)
   {
     int w=vtkObject::GetGlobalWarningDisplay();
     vtkObject::GlobalWarningDisplayOff();
     m_VtkRenderer->ResetCamera();
     vtkObject::SetGlobalWarningDisplay(w);
   }
 }
 
 
 void mitk::VtkPropRenderer::SetMapperID(const MapperSlotId mapperId)
 {
   if(m_MapperID != mapperId)
     Superclass::SetMapperID(mapperId);
 
   // Workaround for GL Displaylist Bug
   checkState();
 }
 
 
 /*!
 \brief Activates the current renderwindow.
 */
 void mitk::VtkPropRenderer::MakeCurrent()
 {
   if(m_RenderWindow!=NULL)
     m_RenderWindow->MakeCurrent();
 }
 
 
 void mitk::VtkPropRenderer::PickWorldPoint(const mitk::Point2D& displayPoint, mitk::Point3D& worldPoint) const
 {
   if(m_VtkMapperPresent)
   {
     //m_WorldPointPicker->SetTolerance (0.0001);
     switch ( m_PickingMode )
     {
     case (WorldPointPicking) :
       {
         m_WorldPointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
         vtk2itk(m_WorldPointPicker->GetPickPosition(), worldPoint);
         break;
       }
     case (PointPicking) :
       {
         // create a new vtkRenderer
         // give it all necessary information (camera position, etc.)
         // get all surfaces from datastorage, get actors from them
         // add all those actors to the new renderer
         // give this new renderer to pointpicker
         /*
        vtkRenderer* pickingRenderer = vtkRenderer::New();
        pickingRenderer->SetActiveCamera( );
 
        DataStorage* dataStorage = m_DataStorage;
        TNodePredicateDataType<Surface> isSurface;
 
        DataStorage::SetOfObjects::ConstPointer allSurfaces = dataStorage->GetSubset( isSurface );
        MITK_INFO << "in picking: got " << allSurfaces->size() << " surfaces." << std::endl;
 
        for (DataStorage::SetOfObjects::const_iterator iter = allSurfaces->begin();
             iter != allSurfaces->end();
             ++iter)
        {
          const DataNode* currentNode = *iter;
          VtkMapper3D* baseVtkMapper3D = dynamic_cast<VtkMapper3D*>( currentNode->GetMapper( BaseRenderer::Standard3D ) );
          if ( baseVtkMapper3D )
          {
            vtkActor* actor = dynamic_cast<vtkActor*>( baseVtkMapper3D->GetViewProp() );
            if (actor)
            {
              MITK_INFO << "a" << std::flush;
              pickingRenderer->AddActor( actor );
            }
          }
        }
 
        MITK_INFO << ";" << std::endl;
        */
         m_PointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
         vtk2itk(m_PointPicker->GetPickPosition(), worldPoint);
         break;
       }
     }
   }
   else
   {
     Superclass::PickWorldPoint(displayPoint, worldPoint);
   }
 }
 
 mitk::DataNode *
     mitk::VtkPropRenderer::PickObject( const Point2D &displayPosition, Point3D &worldPosition ) const
 {
   if ( m_VtkMapperPresent )
   {
     m_CellPicker->InitializePickList();
 
     // Iterate over all DataStorage objects to determine all vtkProps intended
     // for picking
     DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
     for ( DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();
     it != allObjects->End();
     ++it )
     {
       DataNode *node = it->Value();
       if ( node == NULL )
         continue;
 
       bool pickable = false;
       node->GetBoolProperty( "pickable", pickable );
       if ( !pickable )
         continue;
 
       VtkMapper3D *mapper = dynamic_cast< VtkMapper3D * >
                             ( node->GetMapper( m_MapperID ) );
       if ( mapper == NULL )
         continue;
 
       vtkProp *prop = mapper->GetVtkProp( (mitk::BaseRenderer *)this );
       if ( prop == NULL )
         continue;
 
       m_CellPicker->AddPickList( prop );
     }  
 
 
     // Do the picking and retrieve the picked vtkProp (if any)
     m_CellPicker->PickFromListOn();
     m_CellPicker->Pick( displayPosition[0], displayPosition[1], 0.0, m_VtkRenderer );
     m_CellPicker->PickFromListOff();
 
     vtk2itk( m_CellPicker->GetPickPosition(), worldPosition );
     vtkProp *prop = m_CellPicker->GetViewProp();
 
     if ( prop == NULL )
     {
       return NULL;
     }
 
     // Iterate over all DataStorage objects to determine if the retrieved
     // vtkProp is owned by any associated mapper.
     for ( DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin();
     it != allObjects->End();
     ++it)
     {
       DataNode::Pointer node = it->Value();
       if ( node.IsNull() )
         continue;
 
       mitk::Mapper::Pointer mapper = node->GetMapper( m_MapperID );
       if ( mapper.IsNull() )
         continue;
 
       if ( mapper->HasVtkProp( prop, const_cast< mitk::VtkPropRenderer * >( this ) ) )
       {
         return node;
       }
     }  
 
     return NULL;
   }
   else
   {
     return Superclass::PickObject( displayPosition, worldPosition ); 
   }
 };
 
 
 
 /*!
 \brief Writes some 2D text as overlay. Function returns an unique int Text_ID for each call, which can be used via the GetTextLabelProperty(int text_id) function
 in order to get a vtkTextProperty. This property enables the setup of font, font size, etc.
 */
-int mitk::VtkPropRenderer::WriteSimpleText(std::string text, double posX, double posY, double color1, double color2, double color3)
+int mitk::VtkPropRenderer::WriteSimpleText(std::string text, double posX, double posY, double color1, double color2, double color3, float opacity)
 {
   if(text.size() > 0)
   {
     vtkTextActor* textActor = vtkTextActor::New();
 
     textActor->SetPosition(posX,posY);
     textActor->SetInput(text.c_str());
     textActor->GetTextProperty()->SetColor(color1, color2, color3); //TODO: Read color from node property
+    textActor->GetTextProperty()->SetOpacity( opacity );
     int text_id = m_TextCollection.size();
     m_TextCollection.insert(TextMapType::value_type(text_id,textActor));
     return text_id;
   }
   return -1;
 }
 
 
 /*!
 \brief Can be used in order to get a vtkTextProperty for a specific text_id. This property enables the setup of font, font size, etc.
 */
 vtkTextProperty* mitk::VtkPropRenderer::GetTextLabelProperty(int text_id)
 {
   return this->m_TextCollection[text_id]->GetTextProperty();
 }
 
 
 void mitk::VtkPropRenderer::InitPathTraversal()
 {
   if (m_DataStorage.IsNotNull())
   {
     m_PickingObjects = m_DataStorage->GetAll();
     m_PickingObjectsIterator = m_PickingObjects->begin();
   }
 }
 
 
 vtkAssemblyPath* mitk::VtkPropRenderer::GetNextPath()
 {
   if (m_DataStorage.IsNull() )
   {
     return NULL;
   }
 
   if ( m_PickingObjectsIterator == m_PickingObjects->end() )
   {
     return NULL;
   }
 
   vtkAssemblyPath* returnPath = vtkAssemblyPath::New();
   //returnPath->Register(NULL);
 
   bool success = false;
 
   while (!success)
   {
     // loop until AddNode can be called successfully
     const DataNode* node = *m_PickingObjectsIterator;
     if (node)
     {
       Mapper* mapper = node->GetMapper( BaseRenderer::Standard3D );
       if (mapper)
       {
         VtkMapper3D* vtkmapper = dynamic_cast<VtkMapper3D*>( mapper );
         if (vtkmapper)
         {
           vtkProp* prop = vtkmapper->GetVtkProp(this);
           if ( prop && prop->GetVisibility() )
           {
             // add to assembly path
             returnPath->AddNode( prop, prop->GetMatrix() );
             success = true;
           }
         }
       }
     }
 
     ++m_PickingObjectsIterator;
 
     if ( m_PickingObjectsIterator == m_PickingObjects->end() ) break;
   }
 
   if ( success )
   {
     return returnPath;
   }
   else
   {
     return NULL;
   }
 }
 
 
 void mitk::VtkPropRenderer::ReleaseGraphicsResources(vtkWindow *renWin)
 {
   if( m_DataStorage.IsNull() )
     return;
 
   DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
   for (DataStorage::SetOfObjects::const_iterator iter = allObjects->begin(); iter != allObjects->end(); ++iter)
   {
     DataNode::Pointer node = *iter;
     if ( node.IsNull() )
       continue;
 
     Mapper::Pointer mapper = node->GetMapper(m_MapperID);
     if(mapper.IsNotNull())
       mapper->ReleaseGraphicsResources(renWin);
   } 
 }
 
 
 const vtkWorldPointPicker *mitk::VtkPropRenderer::GetWorldPointPicker() const
 {
   return m_WorldPointPicker;
 }
 
 
 const vtkPointPicker *mitk::VtkPropRenderer::GetPointPicker() const
 {
   return m_PointPicker;
 }
 
 
 const vtkCellPicker *mitk::VtkPropRenderer::GetCellPicker() const
 {
   return m_CellPicker;
 }
 
 
 mitk::VtkPropRenderer::MappersMapType mitk::VtkPropRenderer::GetMappersMap() const
 {
   return m_MappersMap;
 }
 
 
 // Workaround for GL Displaylist bug
 
 static int glWorkAroundGlobalCount = 0;
 
 bool mitk::VtkPropRenderer::useImmediateModeRendering()
 {
   return glWorkAroundGlobalCount>1;
 }
 
 void mitk::VtkPropRenderer::checkState()
 {
   if (m_MapperID == Standard3D)
   {
     if (!didCount)
     {
       didCount = true;
       glWorkAroundGlobalCount++;
       
       if (glWorkAroundGlobalCount == 2)
       {
         MITK_INFO << "Multiple 3D Renderwindows active...: turning Immediate Rendering ON for legacy mappers";
         //          vtkMapper::GlobalImmediateModeRenderingOn();
       }
       //MITK_INFO << "GLOBAL 3D INCREASE " << glWorkAroundGlobalCount << "\n";
       
     }
   }
   else
   {
     if(didCount)
     {
       didCount=false;
       glWorkAroundGlobalCount--;
       if(glWorkAroundGlobalCount==1)
       {
         MITK_INFO << "Single 3D Renderwindow active...: turning Immediate Rendering OFF for legacy mappers";
         //        vtkMapper::GlobalImmediateModeRenderingOff();
       }
       //MITK_INFO << "GLOBAL 3D DECREASE " << glWorkAroundGlobalCount << "\n";
     }
   }
 }
 
 //### Contains all methods which are neceassry before each VTK Render() call
 void mitk::VtkPropRenderer::PrepareRender()
 {
   if ( this->GetMapperID() != m_CameraInitializedForMapperID )
   {
     Initialize2DvtkCamera(); //Set parallel projection etc.
   }
 
   AdjustCameraToScene(); //Prepare camera for 2D render windows
 }
 
 bool mitk::VtkPropRenderer::Initialize2DvtkCamera()
 {
   if ( this->GetMapperID() == Standard3D )
   {
     //activate parallel projection for 2D
     this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(false);
     this->GetRenderWindow()->GetInteractor()->SetInteractorStyle( vtkInteractorStyleTrackballCamera::New() );
     m_CameraInitializedForMapperID = Standard3D;
   }
   else if( this->GetMapperID() == Standard2D)
   {
     //activate parallel projection for 2D
     this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(true);
     //turn the light out in the scene in order to render correct grey values.
     //TODO Implement a property for light in the 2D render windows (in another method)
     this->GetVtkRenderer()->RemoveAllLights();
 
     this->GetRenderWindow()->GetInteractor()->SetInteractorStyle( mitkVtkInteractorStyle::New() );
 
     m_CameraInitializedForMapperID = Standard2D;
   }
   return true;
 }
 
 void mitk::VtkPropRenderer::AdjustCameraToScene(){
   if(this->GetMapperID() == Standard2D)
   {
     const mitk::DisplayGeometry* displayGeometry = this->GetDisplayGeometry();
 
     double objectHeightInMM = this->GetCurrentWorldGeometry2D()->GetExtentInMM(1);//the height of the current object slice in mm
     double displayHeightInMM = displayGeometry->GetSizeInMM()[1]; //the display height in mm (gets smaller when you zoom in)
     double zoomFactor = objectHeightInMM/displayHeightInMM; //displayGeometry->GetScaleFactorMMPerDisplayUnit()
     //determine how much of the object can be displayed
 
     Vector2D displayGeometryOriginInMM = displayGeometry->GetOriginInMM();  //top left of the render window (Origin)
     Vector2D displayGeometryCenterInMM = displayGeometryOriginInMM + displayGeometry->GetSizeInMM()*0.5; //center of the render window: (Origin + Size/2)
 
     //Scale the rendered object:
     //The image is scaled by a single factor, because in an orthographic projection sizes
     //are preserved (so you cannot scale X and Y axis with different parameters). The
     //parameter sets the size of the total display-volume. If you set this to the image
     //height, the image plus a border with the size of the image will be rendered.
     //Therefore, the size is imageHeightInMM / 2.
     this->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(objectHeightInMM*0.5 );
     //zooming with the factor calculated by dividing displayHeight through imegeHeight. The factor is inverse, because the VTK zoom method is working inversely.
     this->GetVtkRenderer()->GetActiveCamera()->Zoom(zoomFactor);
 
     //the center of the view-plane
     double viewPlaneCenter[3];
     viewPlaneCenter[0] = displayGeometryCenterInMM[0];
     viewPlaneCenter[1] = displayGeometryCenterInMM[1];
     viewPlaneCenter[2] = 0.0; //the view-plane is located in the XY-plane with Z=0.0
 
     //define which direction is "up" for the ciamera (like default for vtk (0.0, 1.0, 0.0)
     double cameraUp[3];
     cameraUp[0] = 0.0;
     cameraUp[1] = 1.0;
     cameraUp[2] = 0.0;
 
     //the position of the camera (center[0], center[1], 900000)
     double cameraPosition[3];
     cameraPosition[0] = viewPlaneCenter[0];
     cameraPosition[1] = viewPlaneCenter[1];
     cameraPosition[2] = 900000.0; //Reason for 900000: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
 
     //set the camera corresponding to the textured plane
     vtkSmartPointer<vtkCamera> camera = this->GetVtkRenderer()->GetActiveCamera();
     if (camera)
     {
       camera->SetPosition( cameraPosition ); //set the camera position on the textured plane normal (in our case this is the view plane normal)
       camera->SetFocalPoint( viewPlaneCenter ); //set the focal point to the center of the textured plane
       camera->SetViewUp( cameraUp ); //set the view-up for the camera
       //      double distance = sqrt((cameraPosition[2]-viewPlaneCenter[2])*(cameraPosition[2]-viewPlaneCenter[2]));
       //      camera->SetClippingRange(distance-50, distance+50); //Reason for huge range: VTK seems to calculate the clipping planes wrong for small values. See VTK bug (id #7823) in VTK bugtracker.
       camera->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.
     }
 
     const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( this->GetCurrentWorldGeometry2D() );
     if ( planeGeometry != NULL )
     {
       //Transform the camera to the current position (transveral, coronal and saggital 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 (transveral, coronal and saggital plane).
       this->GetVtkRenderer()->GetActiveCamera()->ApplyTransform(trans);
     }
   }
 }
diff --git a/Core/Code/Rendering/mitkVtkPropRenderer.h b/Core/Code/Rendering/mitkVtkPropRenderer.h
index f4832f62f5..eb9690e5b5 100644
--- a/Core/Code/Rendering/mitkVtkPropRenderer.h
+++ b/Core/Code/Rendering/mitkVtkPropRenderer.h
@@ -1,240 +1,240 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef MITKVtkPropRenderer_H_HEADER_INCLUDED_C1C29F6D
 #define MITKVtkPropRenderer_H_HEADER_INCLUDED_C1C29F6D
 
 #include <MitkExports.h>
 #include "mitkBaseRenderer.h"
 #include "mitkDataStorage.h"
 #include "mitkRenderingManager.h"
 
 #include <itkCommand.h>
 
 #include <map>
 #include <utility>
 
 class vtkRenderWindow;
 class vtkLight;
 class vtkLightKit;
 class vtkWorldPointPicker;
 class vtkPointPicker;
 class vtkCellPicker;
 class vtkTextActor;
 class vtkTextProperty;
 class vtkAssemblyPath;
 
 
 namespace mitk 
 {
 
 class Mapper;
 
 /*!
 \brief VtkPropRenderer
 
 VtkPropRenderer organizes the MITK rendering process. The MITK rendering process is completely integrated into the VTK rendering pipeline.
 The vtkMitkRenderProp is a custom vtkProp derived class, which implements the rendering interface between MITK and VTK. It redirects render() calls to the VtkPropRenderer, which is responsible for rendering of the datatreenodes.
 VtkPropRenderer replaces the old OpenGLRenderer.
 
 \sa rendering
 \ingroup rendering
 */
 class MITK_CORE_EXPORT VtkPropRenderer : public BaseRenderer
 {
   // Workaround for Displaylistbug
 private:
   bool didCount;
   void checkState();
 
   // Workaround END
 
 public:
 
   mitkClassMacro(VtkPropRenderer,BaseRenderer);
   mitkNewMacro3Param(VtkPropRenderer, const char*, vtkRenderWindow *, mitk::RenderingManager* );
   
   typedef std::map<int,Mapper*> MappersMapType;
 
   // Render - called by vtkMitkRenderProp, returns the number of props rendered
   enum RenderType{Opaque,Translucent,Overlay,Volumetric};
 
   int Render(RenderType type);
 
   /** \brief This methods contains all method neceassary before a VTK Render() call */
   virtual void PrepareRender();
 
   // Active current renderwindow
   virtual void MakeCurrent();
 
   virtual void SetDataStorage( mitk::DataStorage* storage );  ///< set the datastorage that will be used for rendering
 
   virtual void InitRenderer(vtkRenderWindow* renderwindow);
   virtual void Update(mitk::DataNode* datatreenode);
   virtual void SetMapperID(const MapperSlotId mapperId);
 
   // Size
   virtual void InitSize(int w, int h);
   virtual void Resize(int w, int h);
 
   // Picking
   enum PickingMode{ WorldPointPicking, PointPicking };
   itkSetEnumMacro( PickingMode, PickingMode );
   itkGetEnumMacro( PickingMode, PickingMode );
 
   virtual void PickWorldPoint(const Point2D& displayPoint, Point3D& worldPoint) const;
   virtual mitk::DataNode *PickObject( const Point2D &displayPosition, Point3D &worldPosition ) const;
 
   // Simple text rendering method
-  int WriteSimpleText(std::string text, double posX, double posY, double color1 = 0.0, double color2 = 1.0, double color3 = 0.0);
+  int WriteSimpleText(std::string text, double posX, double posY, double color1 = 0.0, double color2 = 1.0, double color3 = 0.0, float opacity = 1.0);
   vtkTextProperty * GetTextLabelProperty(int text_id);
 
   // Initialization / geometry handling
 
   /** This method calculates the bounds of the DataStorage (if it contains any
    * valid data), creates a geometry from these bounds and sets it as world
    * geometry of the renderer.
    *
    * Call this method to re-initialize the renderer to the current DataStorage
    * (e.g. after loading an additional dataset), to ensure that the view is
    * aligned correctly.
    */
   virtual bool SetWorldGeometryToDataStorageBounds();
 
   /**
    * \brief Used by vtkPointPicker/vtkPicker.
    * This will query a list of all objects in MITK and provide every vtk based mapper to the picker.
    */
   void InitPathTraversal();
 
   /**
    * \brief Used by vtkPointPicker/vtkPicker.
    * This will query a list of all objects in MITK and provide every vtk based mapper to the picker.
    */
   vtkAssemblyPath* GetNextPath();
 
   const vtkWorldPointPicker *GetWorldPointPicker() const;
   const vtkPointPicker *GetPointPicker() const;
   const vtkCellPicker *GetCellPicker() const;
 
   /**
   * \brief Release vtk-based graphics resources. Called by
   * vtkMitkRenderProp::ReleaseGraphicsResources.
   */
   virtual void ReleaseGraphicsResources(vtkWindow *renWin);
 
   MappersMapType GetMappersMap() const;
 
   static bool useImmediateModeRendering();
 
 protected:
   VtkPropRenderer( const char* name = "VtkPropRenderer", vtkRenderWindow * renWin = NULL, mitk::RenderingManager* rm = NULL );
   virtual ~VtkPropRenderer();
   virtual void Update();
 
 private:
 
   /** \brief This method sets up the camera on the actor (e.g. an image) of all
   * 2D vtkRenderWindows. The view is centered; zooming and panning of VTK are called inside.
   *
   * \image html ImageMapperdisplayGeometry.png
   *
   * Similar to the textured plane of an image
   * (cf. void mitkImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer* renderer,
   * vtkFloatingPointType planeBounds[6])), the mitkDisplayGeometry defines a view plane (or
   * projection plane). This plane is used to set the camera parameters. The view plane
   * center (VC) is important for camera positioning (cf. the image above).
   *
   * The following figure shows the combination of the textured plane and the view plane.
   *
   * \image html cameraPositioning.png
   *
   * The view plane center (VC) is the center of the textured plane (C) and the focal point
   * (FP) at the same time. The FP defines the direction the camera faces. Since
   * the textured plane is always in the XY-plane and orthographic projection is applied, the
   * distance between camera and plane is theoretically irrelevant (because in the orthographic
   * projection the center of projection is at infinity and the size of objects depends only on
   * a scaling parameter). As a consequence, the direction of projection (DOP) is (0; 0; -1).
   * The camera up vector is always defined as (0; 1; 0).
   *
   * \warning Due to a VTK clipping bug the distance between textured plane and camera is really huge.
   * Otherwise, VTK would clip off some slices. Same applies for the clipping range size.
   *
   * \note The camera position is defined through the mitkDisplayGeometry.
   * This facilitates zooming and panning, because the display
   * geometry changes and the textured plane does not.
   *
   * \image html scaling.png
   *
   * The textured plane is scaled to fill the render window via
   * camera->SetParallelScale( imageHeightInMM / 2). In the orthographic projection all extends,
   * angles and sizes are preserved. Therefore, the image is scaled by one parameter which defines
   * the size of the rendered image. A higher value will result in smaller images. In order to render
   * just the whole image, the scale is set to half of the image height in worldcoordinates
   * (cf. the picture above).
   *
   * For zooming purposes, a factor is computed as follows:
   * factor = image height / display height (in worldcoordinates).
   * When the display geometry gets smaller (zoom in), the factor becomes bigger. When the display
   * geometry gets bigger (zoom out), the factor becomes smaller. The used VTK method
   * camera->Zoom( factor ) also works with an inverse scale.
   */
   void AdjustCameraToScene();
 
   // switch between orthogonal opengl projection (2D rendering via mitk::GLMapper2D) and perspective projection (3D rendering)
   void Enable2DOpenGL();
   void Disable2DOpenGL();
 
   // prepare all mitk::mappers for rendering
   void PrepareMapperQueue();
 
   /** \brief Set parallel projection, remove the interactor and the lights of VTK. */
   bool Initialize2DvtkCamera();
 
   bool m_InitNeeded;
   bool m_ResizeNeeded;
   bool m_VtkMapperPresent;
   bool m_NewRenderer;
   MapperSlotId m_CameraInitializedForMapperID;
 
   // Picking
   vtkWorldPointPicker     * m_WorldPointPicker;
   vtkPointPicker          * m_PointPicker;
   vtkCellPicker           * m_CellPicker;
 
   PickingMode               m_PickingMode;
 
   // Explicit use of SmartPointer to avoid circular #includes
   itk::SmartPointer< mitk::Mapper > m_CurrentWorldGeometry2DMapper;
 
   vtkLightKit* m_LightKit;
 
   // sorted list of mappers
   MappersMapType m_MappersMap;
 
   // rendering of text
   vtkRenderer * m_TextRenderer;
   typedef std::map<unsigned int,vtkTextActor*> TextMapType;
   TextMapType m_TextCollection;
 
   DataStorage::SetOfObjects::ConstPointer m_PickingObjects;
   DataStorage::SetOfObjects::const_iterator m_PickingObjectsIterator;
 };
 
 } // namespace mitk
 
 #endif /* MITKVtkPropRenderer_H_HEADER_INCLUDED_C1C29F6D */
diff --git a/Documentation/Doxygen/Modules/Modules.dox b/Documentation/Doxygen/Modules/Modules.dox
index 57ee480242..67cd78f73e 100644
--- a/Documentation/Doxygen/Modules/Modules.dox
+++ b/Documentation/Doxygen/Modules/Modules.dox
@@ -1,123 +1,123 @@
 /**
   \defgroup Core Core Classes
   
   \brief This category includes classes of the MITK Core library.
 */
 
 /**
   \defgroup Data Data Classes
   \ingroup DataManagement
 
   \brief This subcategory includes the data classes, e.g., for images (mitk::Image), 
   surfaces (mitk::Surface), vessel-trees (mitk::VesselTreeData), etc. 
 
   Data access classes are only included, if there is no equivalent in itk (see 
   \ref ProcessAndAdaptorClasses "Process and Adaptor Classes" below).
 */
 
 /**
   \defgroup IO IO Classes
   \ingroup DataManagement
 
   \brief This subcategory includes the IO classes to read or write data objects.
 */
 
 /**
   \defgroup DataStorage Data Storage Classes
   \ingroup DataManagement
 
   \brief This subcategory includes the classes to store and retrieve objects from the mitk::DataStorage
 */
 
 /**
   \defgroup ProcessAdaptor Process and Adaptor Classes
   \ingroup Core
   \anchor ProcessAndAdaptorClasses
 
   \brief This category includes process (algorithm) classes developed specifically for mitk and 
   (mainly) adaptor classes for the integration of algorithms from other toolkits 
   (currently vtk, itk).
 
   The itk adaptor classes are also useful for data access to mitk data objects.
 */
 
 /**
   \defgroup Process Process Classes
   \ingroup ProcessAdaptor
 
   \brief This subcategory includes process (algorithm) classes developed specifically for mitk.
 */
 
 /**
   \defgroup InteractionUndo Interaction and Undo Classes
   \ingroup Core
 
   \brief This category includes classes that support the developer to create 
   software that allows the user to interact with the data. 
   
   This includes complex interactions that have multiple states (e.g., moving a handle of an 
   active contour vs changing its local elasicity) and a concept to realize an undo/redo-mechanism.
      
   A detailed description of the rationale for these classes can be found in
   \ref InteractionPage.
 */
 
 /**
   \defgroup Interaction Interaction Classes
   \ingroup InteractionUndo
 
   \brief This subcategory includes interaction classes (subclasses of mitk::StateMachine) that change
   the data according to the input of the user. 
   
   For undo-support, the change is done by sending an OperationEvent to the respective 
   data object, which changes itself accordingly.
    
   A detailed description of the rationale for these classes can be found in
   \ref InteractionPage.
 */
 
 /**
   \defgroup Undo Undo Classes
   \ingroup InteractionUndo
 
   \brief This subcategory includes the undo/redo-specific classes. 
   
   For undo-support, the change is done by sending an OperationEvent to the respective data object, 
   which changes itself accordingly.
   
   A detailed description of the rationale for these classes can be found in
   \ref InteractionPage.
 */
  
 /**
-  \defgroup ToolManagerEtAl Classes related to the Segmentation bundle
+  \defgroup ToolManagerEtAl Classes related to the Segmentation plugin
 
-  \brief A couple of classes related to the Segmentation bundle. See also
+  \brief A couple of classes related to the Segmentation plugin. See also
   \ref QmitkSegmentationTechnicalPage
 */
 
 /**
   \defgroup Registration Registration
 
   \brief A couple of classes related to registration.
 */
 
 /**
   \defgroup RigidRegistration Classes related to rigid registration
   \ingroup Registration
   
   \brief A couple of classes related to rigid registration.
 */
 
 /**
   \defgroup PointBasedRegistration Classes related to point based registration
   \ingroup Registration
   
   \brief A couple of classes related to point based registration.
 */
 
 /**
   \defgroup MITKPlugins MITK Plugins
   
   \brief This group includes all MITK Plugins
 */
diff --git a/Documentation/Doxygen/UserManual/Applications.dox b/Documentation/Doxygen/UserManual/Applications.dox
index fc0c286f5d..2a6b7db404 100644
--- a/Documentation/Doxygen/UserManual/Applications.dox
+++ b/Documentation/Doxygen/UserManual/Applications.dox
@@ -1,30 +1,30 @@
 /**
 \page ApplicationsPage Using MITK and Applications
 
 Available sections:
   - \ref ApplicationsPageUsingMITK
   - \ref ApplicationsPageApplications
   - \ref ApplicationsPageApplicationsList
 
 \section ApplicationsPageUsingMITK Using MITK
 
-Many of the applications created with the use of MITK share common basic functionalities. Due to this, there is one manual which explains the basic usage of MITK. For more information on the use of the advanced features of an application please take a look the \ref ApplicationsPageApplicationsList , whereas if you are interested in a certain view further information can be found in \ref ModuleListPage .
+Many of the applications created with the use of MITK share common basic functionalities. Due to this, there is one manual which explains the basic usage of MITK. For more information on the use of the advanced features of an application please take a look the \ref ApplicationsPageApplicationsList , whereas if you are interested in a certain view further information can be found in \ref PluginListPage .
 
 The basic usage information on MITK can be found in \subpage MITKUserManualPage .
 
 \section ApplicationsPageApplications What are Applications?
 
 Applications are executables, which contain a certain configuration of views and perspectives. Usually they are aimed at a selective audience or solving a particular problem. As such they focus on certain capabilities of MITK, while ignoring others. The main reason for this is to supply the users of the application with the power of MITK for solving their tasks, without daunting them with an overwhelming number of menus and options. At the same time, this allows, together with the use of perspectives, the creation of sleek and elegant workflows, which are easily comprehensible.
 
 A typical example of this would be an application which contains only views related to the analysis of the human brain (particular question) or one which contains only what is necessary for displaying medical data in the classroom (specific audience).
   
 \section ApplicationsPageApplicationsList List of Applications
 
 If you are interested in using a specific application, currently developed by the MITK team you might want to take a look first at the \ref MITKUserManualPage . Further information on any application can be found here:
 <ul>
   <li> \subpage org_mitkworkbench
   <li> \subpage org_dti_atlas_application
   <li> \subpage org_mitk_gui_qt_diffusionimagingapp
 </ul>
 
 */
\ No newline at end of file
diff --git a/Documentation/Doxygen/UserManual/MITKModuleManualsList.dox b/Documentation/Doxygen/UserManual/MITKModuleManualsList.dox
new file mode 100644
index 0000000000..63000a2782
--- /dev/null
+++ b/Documentation/Doxygen/UserManual/MITKModuleManualsList.dox
@@ -0,0 +1,17 @@
+/**
+\page MITKModuleManualsListPage MITK Module Manuals
+
+\section MITKModuleManualsListPageOverview Overview
+
+The modules are shared libraries that provide functionality that can be used by developers.
+
+\section MITKModuleManualsListPageModuleManualList List of Module Manuals
+
+  \li \subpage IGTGeneralModulePage
+
+\section MITKModuleManualsListPageAdditionalInformation Additional Information on Certain Modules
+
+  \li \ref PlanarPropertiesPage
+  \li \subpage DiffusionImagingPropertiesPage
+
+*/
diff --git a/Documentation/Doxygen/UserManual/ModuleList.dox b/Documentation/Doxygen/UserManual/MITKPluginManualsList.dox
similarity index 66%
rename from Documentation/Doxygen/UserManual/ModuleList.dox
rename to Documentation/Doxygen/UserManual/MITKPluginManualsList.dox
index de720208ee..26c53b8a28 100644
--- a/Documentation/Doxygen/UserManual/ModuleList.dox
+++ b/Documentation/Doxygen/UserManual/MITKPluginManualsList.dox
@@ -1,34 +1,37 @@
 /**
-\page ModuleListPage MITK Modules
+\page PluginListPage MITK Plugin Manuals
 
-\section ModuleListPageOverview Overview
+\section PluginListPageOverview Overview
 
-The modules and bundles provide much of the extended functionality of MITK. Each encapsulates a solution to a problem and associated features. This way one can easily assemble the necessary capabilites for a workflow without adding a lot of bloat, by combining modules as needed.
+The plugins and bundles provide much of the extended functionality of MITK. Each encapsulates a solution to a problem and associated features. This way one can easily assemble the necessary capabilites for a workflow without adding a lot of bloat, by combining plugins as needed.
 
-The distinction between developer and end user use is for convenience only and mainly distinguishes which group a module is primarily aimed at.
+The distinction between developer and end user use is for convenience only and mainly distinguishes which group a plugin is primarily aimed at.
 
-\section ModuleListPageEndUserModuleList List of Modules for End User Use
+\section PluginListPageEndUserPluginList List of Plugins for End User Use
 
   \li \subpage org_mitk_views_basicimageprocessing
   \li \subpage org_mitk_views_datamanager
   \li \subpage org_mitk_gui_qt_diffusionimaging
-  \li \subpage IGTGeneralModulePage
   \li \subpage org_mitk_views_imagecropper
   \li \subpage org_mitk_views_imagenavigator
   \li \subpage org_mitk_gui_qt_measurementtoolbox
   \li \subpage org_mitk_views_moviemaker
   \li \subpage org_mitk_views_meshdecimation
   \li \subpage org_mitk_views_pointsetinteraction
   \li \subpage org_mitk_gui_qt_registration
   \li \subpage org_mitk_views_segmentation
   \li \subpage org_mitk_views_volumevisualization
-  
-\section ModuleListPageDevModuleList List of Modules for Developer Use and Examples
+  \li \subpage org_mitk_gui_qt_dicom
+  \li \subpage org_mitk_gui_qt_ultrasound
+
+\section PluginListPageDevPluginList List of Plugins for Developer Use and Examples
 
   \li \subpage org_surfacematerialeditor
   \li \subpage org_toftutorial
   \li \subpage org_mitk_gui_qt_examples
   \li \subpage org_mitkexamplesopencv
+  \li \ref org_mitk_gui_qt_igtexample
+  \li \ref org_mitk_gui_qt_igttracking
+
 
-  
 */
diff --git a/Documentation/MITKDoxygenLayout.xml b/Documentation/MITKDoxygenLayout.xml
new file mode 100644
index 0000000000..19afb000f9
--- /dev/null
+++ b/Documentation/MITKDoxygenLayout.xml
@@ -0,0 +1,188 @@
+<doxygenlayout version="1.0">
+  <!-- Navigation index tabs for HTML output -->
+  <navindex>
+    <tab type="mainpage" visible="yes" title=""/>
+    <tab type="pages" visible="yes" title="" intro=""/>
+    <tab type="modules" visible="yes" title="MITK API Documentation" intro="The following documentation is available for the MITK API"/>
+    <tab type="namespaces" visible="yes" title="">
+      <tab type="namespacelist" visible="yes" title="" intro=""/>
+      <tab type="namespacemembers" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="classes" visible="yes" title="">
+      <tab type="classlist" visible="yes" title="" intro=""/>
+      <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
+      <tab type="hierarchy" visible="yes" title="" intro=""/>
+      <tab type="classmembers" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="files" visible="yes" title="">
+      <tab type="filelist" visible="yes" title="" intro=""/>
+      <tab type="globals" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="dirs" visible="yes" title="" intro=""/>
+    <tab type="examples" visible="yes" title="" intro=""/>
+  </navindex>
+
+  <!-- Layout definition for a class page -->
+  <class>
+    <briefdescription visible="yes"/>
+    <includes visible="$SHOW_INCLUDE_FILES"/>
+    <inheritancegraph visible="$CLASS_GRAPH"/>
+    <collaborationgraph visible="$COLLABORATION_GRAPH"/>
+    <allmemberslink visible="yes"/>
+    <memberdecl>
+      <nestedclasses visible="yes" title=""/>
+      <publictypes title=""/>
+      <publicslots title=""/>
+      <signals title=""/>
+      <publicmethods title=""/>
+      <publicstaticmethods title=""/>
+      <publicattributes title=""/>
+      <publicstaticattributes title=""/>
+      <protectedtypes title=""/>
+      <protectedslots title=""/>
+      <protectedmethods title=""/>
+      <protectedstaticmethods title=""/>
+      <protectedattributes title=""/>
+      <protectedstaticattributes title=""/>
+      <packagetypes title=""/>
+      <packagemethods title=""/>
+      <packagestaticmethods title=""/>
+      <packageattributes title=""/>
+      <packagestaticattributes title=""/>
+      <properties title=""/>
+      <events title=""/>
+      <privatetypes title=""/>
+      <privateslots title=""/>
+      <privatemethods title=""/>
+      <privatestaticmethods title=""/>
+      <privateattributes title=""/>
+      <privatestaticattributes title=""/>
+      <friends title=""/>
+      <related title="" subtitle=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <constructors title=""/>
+      <functions title=""/>
+      <related title=""/>
+      <variables title=""/>
+      <properties title=""/>
+      <events title=""/>
+    </memberdef>
+    <usedfiles visible="$SHOW_USED_FILES"/>
+    <authorsection visible="yes"/>
+  </class>
+
+  <!-- Layout definition for a namespace page -->
+  <namespace>
+    <briefdescription visible="yes"/>
+    <memberdecl>
+      <nestednamespaces visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+    </memberdef>
+    <authorsection visible="yes"/>
+  </namespace>
+
+  <!-- Layout definition for a file page -->
+  <file>
+    <briefdescription visible="yes"/>
+    <includes visible="$SHOW_INCLUDE_FILES"/>
+    <includegraph visible="$INCLUDE_GRAPH"/>
+    <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
+    <sourcelink visible="yes"/>
+    <memberdecl>
+      <classes visible="yes" title=""/>
+      <namespaces visible="yes" title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+    </memberdef>
+    <authorsection/>
+  </file>
+
+  <!-- Layout definition for a group page -->
+  <group>
+    <briefdescription visible="yes"/>
+    <groupgraph visible="$GROUP_GRAPHS"/>
+    <memberdecl>
+      <nestedgroups visible="yes" title=""/>
+      <dirs visible="yes" title=""/>
+      <files visible="yes" title=""/>
+      <namespaces visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <enumvalues title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <signals title=""/>
+      <publicslots title=""/>
+      <protectedslots title=""/>
+      <privateslots title=""/>
+      <events title=""/>
+      <properties title=""/>
+      <friends title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <pagedocs/>
+      <inlineclasses title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <enumvalues title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <signals title=""/>
+      <publicslots title=""/>
+      <protectedslots title=""/>
+      <privateslots title=""/>
+      <events title=""/>
+      <properties title=""/>
+      <friends title=""/>
+    </memberdef>
+    <authorsection visible="yes"/>
+  </group>
+
+  <!-- Layout definition for a directory page -->
+  <directory>
+    <briefdescription visible="yes"/>
+    <directorygraph visible="yes"/>
+    <memberdecl>
+      <dirs visible="yes"/>
+      <files visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+  </directory>
+</doxygenlayout>
diff --git a/Documentation/doxygen.conf.in b/Documentation/doxygen.conf.in
index f6eb26cfe3..42076c5282 100644
--- a/Documentation/doxygen.conf.in
+++ b/Documentation/doxygen.conf.in
@@ -1,1912 +1,1914 @@
 # Doxyfile 1.8.0
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
 #
 # All text after a hash (#) is considered a comment and will be ignored.
 # The format is:
 #       TAG = value [value, ...]
 # For lists items can also be appended using:
 #       TAG += value [value, ...]
 # Values that contain spaces should be placed between quotes (" ").
 
 #---------------------------------------------------------------------------
 # Project related configuration options
 #---------------------------------------------------------------------------
 
 # This tag specifies the encoding used for all characters in the config file
 # that follow. The default is UTF-8 which is also the encoding used for all
 # text before the first occurrence of this tag. Doxygen uses libiconv (or the
 # iconv built into libc) for the transcoding. See
 # http://www.gnu.org/software/libiconv for the list of possible encodings.
 
 DOXYFILE_ENCODING      = UTF-8
 
 # The PROJECT_NAME tag is a single word (or sequence of words) that should
 # identify the project. Note that if you do not use Doxywizard you need
 # to put quotes around the project name if it contains spaces.
 
 PROJECT_NAME           = MITK
 
 # The PROJECT_NUMBER tag can be used to enter a project or revision number.
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.
 
 PROJECT_NUMBER         = @MITK_VERSION_STRING@
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer
 # a quick idea about the purpose of the project. Keep the description short.
 
 PROJECT_BRIEF          = "Medical Imaging Interaction Toolkit"
 
 # With the PROJECT_LOGO tag one can specify an logo or icon that is
 # included in the documentation. The maximum height of the logo should not
 # exceed 55 pixels and the maximum width should not exceed 200 pixels.
 # Doxygen will copy the logo to the output directory.
 
 PROJECT_LOGO           =
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
 # base path where the generated documentation will be put.
 # If a relative path is entered, it will be relative to the location
 # where doxygen was started. If left blank the current directory will be used.
 
 OUTPUT_DIRECTORY       = @MITK_DOXYGEN_OUTPUT_DIR@
 
 # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
 # 4096 sub-directories (in 2 levels) under the output directory of each output
 # format and will distribute the generated files over these directories.
 # Enabling this option can be useful when feeding doxygen a huge amount of
 # source files, where putting all generated files in the same directory would
 # otherwise cause performance problems for the file system.
 
 CREATE_SUBDIRS         = NO
 
 # The OUTPUT_LANGUAGE tag is used to specify the language in which all
 # documentation generated by doxygen is written. Doxygen will use this
 # information to generate all constant output in the proper language.
 # The default language is English, other supported languages are:
 # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
 # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
 # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
 # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
 # Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
 # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
 
 OUTPUT_LANGUAGE        = English
 
 # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
 # include brief member descriptions after the members that are listed in
 # the file and class documentation (similar to JavaDoc).
 # Set to NO to disable this.
 
 BRIEF_MEMBER_DESC      = YES
 
 # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
 # the brief description of a member or function before the detailed description.
 # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
 # brief descriptions will be completely suppressed.
 
 REPEAT_BRIEF           = YES
 
 # This tag implements a quasi-intelligent brief description abbreviator
 # that is used to form the text in various listings. Each string
 # in this list, if found as the leading text of the brief description, will be
 # stripped from the text and the result after processing the whole list, is
 # used as the annotated text. Otherwise, the brief description is used as-is.
 # If left blank, the following values are used ("$name" is automatically
 # replaced with the name of the entity): "The $name class" "The $name widget"
 # "The $name file" "is" "provides" "specifies" "contains"
 # "represents" "a" "an" "the"
 
 ABBREVIATE_BRIEF       =
 
 # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
 # Doxygen will generate a detailed section even if there is only a brief
 # description.
 
 ALWAYS_DETAILED_SEC    = NO
 
 # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
 # inherited members of a class in the documentation of that class as if those
 # members were ordinary class members. Constructors, destructors and assignment
 # operators of the base classes will not be shown.
 
 INLINE_INHERITED_MEMB  = NO
 
 # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
 # path before files name in the file list and in the header files. If set
 # to NO the shortest path that makes the file name unique will be used.
 
 FULL_PATH_NAMES        = NO
 
 # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
 # can be used to strip a user-defined part of the path. Stripping is
 # only done if one of the specified strings matches the left-hand part of
 # the path. The tag can be used to show relative paths in the file list.
 # If left blank the directory from which doxygen is run is used as the
 # path to strip.
 
 STRIP_FROM_PATH        =
 
 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
 # the path mentioned in the documentation of a class, which tells
 # the reader which header file to include in order to use a class.
 # If left blank only the name of the header file containing the class
 # definition is used. Otherwise one should specify the include paths that
 # are normally passed to the compiler using the -I flag.
 
 STRIP_FROM_INC_PATH    =
 
 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
 # (but less readable) file names. This can be useful if your file system
 # doesn't support long names like on DOS, Mac, or CD-ROM.
 
 SHORT_NAMES            = NO
 
 # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
 # will interpret the first line (until the first dot) of a JavaDoc-style
 # comment as the brief description. If set to NO, the JavaDoc
 # comments will behave just like regular Qt-style comments
 # (thus requiring an explicit @brief command for a brief description.)
 
 JAVADOC_AUTOBRIEF      = NO
 
 # If the QT_AUTOBRIEF tag is set to YES then Doxygen will
 # interpret the first line (until the first dot) of a Qt-style
 # comment as the brief description. If set to NO, the comments
 # will behave just like regular Qt-style comments (thus requiring
 # an explicit \brief command for a brief description.)
 
 QT_AUTOBRIEF           = NO
 
 # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
 # treat a multi-line C++ special comment block (i.e. a block of //! or ///
 # comments) as a brief description. This used to be the default behaviour.
 # The new default is to treat a multi-line C++ comment block as a detailed
 # description. Set this tag to YES if you prefer the old behaviour instead.
 
 MULTILINE_CPP_IS_BRIEF = NO
 
 # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
 # member inherits the documentation from any documented member that it
 # re-implements.
 
 INHERIT_DOCS           = YES
 
 # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
 # a new page for each member. If set to NO, the documentation of a member will
 # be part of the file/class/namespace that contains it.
 
 SEPARATE_MEMBER_PAGES  = NO
 
 # The TAB_SIZE tag can be used to set the number of spaces in a tab.
 # Doxygen uses this value to replace tabs by spaces in code fragments.
 
 TAB_SIZE               = 8
 
 # This tag can be used to specify a number of aliases that acts
 # as commands in the documentation. An alias has the form "name=value".
 # For example adding "sideeffect=\par Side Effects:\n" will allow you to
 # put the command \sideeffect (or @sideeffect) in the documentation, which
 # will result in a user-defined paragraph with heading "Side Effects:".
 # You can put \n's in the value part of an alias to insert newlines.
 
 ALIASES                = "FIXME=\par Fix Me's:\n" \
                          "BlueBerry=\if BLUEBERRY" \
                          "endBlueBerry=\endif" \
                          "bundlemainpage{1}=\page \1" \
-                         "embmainpage{1}=\page \1"
+                         "embmainpage{1}=\page \1" \
+                         "deprecatedSince{1}=\xrefitem deprecatedSince\1 \" Deprecated as of \1\" \"Functions deprecated as of \1\" "
 
 # This tag can be used to specify a number of word-keyword mappings (TCL only).
 # A mapping has the form "name=value". For example adding
 # "class=itcl::class" will allow you to use the command class in the
 # itcl::class meaning.
 
 TCL_SUBST              =
 
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
 # sources only. Doxygen will then generate output that is more tailored for C.
 # For instance, some of the names that are used will be different. The list
 # of all members will be omitted, etc.
 
 OPTIMIZE_OUTPUT_FOR_C  = NO
 
 # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
 # sources only. Doxygen will then generate output that is more tailored for
 # Java. For instance, namespaces will be presented as packages, qualified
 # scopes will look different, etc.
 
 OPTIMIZE_OUTPUT_JAVA   = NO
 
 # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
 # sources only. Doxygen will then generate output that is more tailored for
 # Fortran.
 
 OPTIMIZE_FOR_FORTRAN   = NO
 
 # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
 # sources. Doxygen will then generate output that is tailored for
 # VHDL.
 
 OPTIMIZE_OUTPUT_VHDL   = NO
 
 # Doxygen selects the parser to use depending on the extension of the files it
 # parses. With this tag you can assign which parser to use for a given extension.
 # Doxygen has a built-in mapping, but you can override or extend it using this
 # tag. The format is ext=language, where ext is a file extension, and language
 # is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
 # C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
 # doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
 # (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
 # you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
 
 EXTENSION_MAPPING      =
 
 # If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
 # comments according to the Markdown format, which allows for more readable
 # documentation. See http://daringfireball.net/projects/markdown/ for details.
 # The output of markdown processing is further processed by doxygen, so you
 # can mix doxygen, HTML, and XML commands with Markdown formatting.
 # Disable only in case of backward compatibilities issues.
 
 MARKDOWN_SUPPORT       = YES
 
 # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
 # to include (a tag file for) the STL sources as input, then you should
 # set this tag to YES in order to let doxygen match functions declarations and
 # definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
 # func(std::string) {}). This also makes the inheritance and collaboration
 # diagrams that involve STL classes more complete and accurate.
 
 BUILTIN_STL_SUPPORT    = YES
 
 # If you use Microsoft's C++/CLI language, you should set this option to YES to
 # enable parsing support.
 
 CPP_CLI_SUPPORT        = NO
 
 # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
 # Doxygen will parse them like normal C++ but will assume all classes use public
 # instead of private inheritance when no explicit protection keyword is present.
 
 SIP_SUPPORT            = NO
 
 # For Microsoft's IDL there are propget and propput attributes to indicate getter
 # and setter methods for a property. Setting this option to YES (the default)
 # will make doxygen replace the get and set methods by a property in the
 # documentation. This will only work if the methods are indeed getting or
 # setting a simple type. If this is not the case, or you want to show the
 # methods anyway, you should set this option to NO.
 
 IDL_PROPERTY_SUPPORT   = YES
 
 # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
 # tag is set to YES, then doxygen will reuse the documentation of the first
 # member in the group (if any) for the other members of the group. By default
 # all members of a group must be documented explicitly.
 
 DISTRIBUTE_GROUP_DOC   = NO
 
 # Set the SUBGROUPING tag to YES (the default) to allow class member groups of
 # the same type (for instance a group of public functions) to be put as a
 # subgroup of that type (e.g. under the Public Functions section). Set it to
 # NO to prevent subgrouping. Alternatively, this can be done per class using
 # the \nosubgrouping command.
 
 SUBGROUPING            = YES
 
 # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
 # unions are shown inside the group in which they are included (e.g. using
 # @ingroup) instead of on a separate page (for HTML and Man pages) or
 # section (for LaTeX and RTF).
 
 INLINE_GROUPED_CLASSES = NO
 
 # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
 # unions with only public data fields will be shown inline in the documentation
 # of the scope in which they are defined (i.e. file, namespace, or group
 # documentation), provided this scope is documented. If set to NO (the default),
 # structs, classes, and unions are shown on a separate page (for HTML and Man
 # pages) or section (for LaTeX and RTF).
 
 INLINE_SIMPLE_STRUCTS  = NO
 
 # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
 # is documented as struct, union, or enum with the name of the typedef. So
 # typedef struct TypeS {} TypeT, will appear in the documentation as a struct
 # with name TypeT. When disabled the typedef will appear as a member of a file,
 # namespace, or class. And the struct will be named TypeS. This can typically
 # be useful for C code in case the coding convention dictates that all compound
 # types are typedef'ed and only the typedef is referenced, never the tag name.
 
 TYPEDEF_HIDES_STRUCT   = NO
 
 # The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
 # determine which symbols to keep in memory and which to flush to disk.
 # When the cache is full, less often used symbols will be written to disk.
 # For small to medium size projects (<1000 input files) the default value is
 # probably good enough. For larger projects a too small cache size can cause
 # doxygen to be busy swapping symbols to and from disk most of the time
 # causing a significant performance penalty.
 # If the system has enough physical memory increasing the cache will improve the
 # performance by keeping more symbols in memory. Note that the value works on
 # a logarithmic scale so increasing the size by one will roughly double the
 # memory usage. The cache size is given by this formula:
 # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
 # corresponding to a cache size of 2^16 = 65536 symbols.
 
 SYMBOL_CACHE_SIZE      = 0
 
 # Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
 # set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
 # their name and scope. Since this can be an expensive process and often the
 # same symbol appear multiple times in the code, doxygen keeps a cache of
 # pre-resolved symbols. If the cache is too small doxygen will become slower.
 # If the cache is too large, memory is wasted. The cache size is given by this
 # formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
 # corresponding to a cache size of 2^16 = 65536 symbols.
 
 LOOKUP_CACHE_SIZE      = 0
 
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
 
 # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
 # documentation are documented, even if no documentation was available.
 # Private class members and static file members will be hidden unless
 # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
 
 EXTRACT_ALL            = YES
 
 # If the EXTRACT_PRIVATE tag is set to YES all private members of a class
 # will be included in the documentation.
 
 EXTRACT_PRIVATE        = NO
 
 # If the EXTRACT_PACKAGE tag is set to YES all members with package or internal scope will be included in the documentation.
 
 EXTRACT_PACKAGE        = NO
 
 # If the EXTRACT_STATIC tag is set to YES all static members of a file
 # will be included in the documentation.
 
 EXTRACT_STATIC         = YES
 
 # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
 # defined locally in source files will be included in the documentation.
 # If set to NO only classes defined in header files are included.
 
 EXTRACT_LOCAL_CLASSES  = @MITK_DOXYGEN_INTERNAL_DOCS@
 
 # This flag is only useful for Objective-C code. When set to YES local
 # methods, which are defined in the implementation section but not in
 # the interface are included in the documentation.
 # If set to NO (the default) only methods in the interface are included.
 
 EXTRACT_LOCAL_METHODS  = NO
 
 # If this flag is set to YES, the members of anonymous namespaces will be
 # extracted and appear in the documentation as a namespace called
 # 'anonymous_namespace{file}', where file will be replaced with the base
 # name of the file that contains the anonymous namespace. By default
 # anonymous namespaces are hidden.
 
 EXTRACT_ANON_NSPACES   = NO
 
 # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
 # undocumented members of documented classes, files or namespaces.
 # If set to NO (the default) these members will be included in the
 # various overviews, but no documentation section is generated.
 # This option has no effect if EXTRACT_ALL is enabled.
 
 HIDE_UNDOC_MEMBERS     = NO
 
 # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
 # undocumented classes that are normally visible in the class hierarchy.
 # If set to NO (the default) these classes will be included in the various
 # overviews. This option has no effect if EXTRACT_ALL is enabled.
 
 HIDE_UNDOC_CLASSES     = NO
 
 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
 # friend (class|struct|union) declarations.
 # If set to NO (the default) these declarations will be included in the
 # documentation.
 
 HIDE_FRIEND_COMPOUNDS  = @MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS@
 
 # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
 # documentation blocks found inside the body of a function.
 # If set to NO (the default) these blocks will be appended to the
 # function's detailed documentation block.
 
 HIDE_IN_BODY_DOCS      = NO
 
 # The INTERNAL_DOCS tag determines if documentation
 # that is typed after a \internal command is included. If the tag is set
 # to NO (the default) then the documentation will be excluded.
 # Set it to YES to include the internal documentation.
 
 INTERNAL_DOCS          = @MITK_DOXYGEN_INTERNAL_DOCS@
 
 # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
 # file names in lower-case letters. If set to YES upper-case letters are also
 # allowed. This is useful if you have classes or files whose names only differ
 # in case and if your file system supports case sensitive file names. Windows
 # and Mac users are advised to set this option to NO.
 
 CASE_SENSE_NAMES       = YES
 
 # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
 # will show members with their full class and namespace scopes in the
 # documentation. If set to YES the scope will be hidden.
 
 HIDE_SCOPE_NAMES       = NO
 
 # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
 # will put a list of the files that are included by a file in the documentation
 # of that file.
 
 SHOW_INCLUDE_FILES     = YES
 
 # If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
 # will list include files with double quotes in the documentation
 # rather than with sharp brackets.
 
 FORCE_LOCAL_INCLUDES   = NO
 
 # If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
 # is inserted in the documentation for inline members.
 
 INLINE_INFO            = YES
 
 # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
 # will sort the (detailed) documentation of file and class members
 # alphabetically by member name. If set to NO the members will appear in
 # declaration order.
 
 SORT_MEMBER_DOCS       = YES
 
 # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
 # brief documentation of file, namespace and class members alphabetically
 # by member name. If set to NO (the default) the members will appear in
 # declaration order.
 
 SORT_BRIEF_DOCS        = NO
 
 # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
 # will sort the (brief and detailed) documentation of class members so that
 # constructors and destructors are listed first. If set to NO (the default)
 # the constructors will appear in the respective orders defined by
 # SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
 # This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
 # and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
 
 SORT_MEMBERS_CTORS_1ST = NO
 
 # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
 # hierarchy of group names into alphabetical order. If set to NO (the default)
 # the group names will appear in their defined order.
 
 SORT_GROUP_NAMES       = NO
 
 # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
 # sorted by fully-qualified names, including namespaces. If set to
 # NO (the default), the class list will be sorted only by class name,
 # not including the namespace part.
 # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
 # Note: This option applies only to the class list, not to the
 # alphabetical list.
 
 SORT_BY_SCOPE_NAME     = YES
 
 # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
 # do proper type resolution of all parameters of a function it will reject a
 # match between the prototype and the implementation of a member function even
 # if there is only one candidate or it is obvious which candidate to choose
 # by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
 # will still accept a match between prototype and implementation in such cases.
 
 STRICT_PROTO_MATCHING  = NO
 
 # The GENERATE_TODOLIST tag can be used to enable (YES) or
 # disable (NO) the todo list. This list is created by putting \todo
 # commands in the documentation.
 
 GENERATE_TODOLIST      = @MITK_DOXYGEN_GENERATE_TODOLIST@
 
 # The GENERATE_TESTLIST tag can be used to enable (YES) or
 # disable (NO) the test list. This list is created by putting \test
 # commands in the documentation.
 
 GENERATE_TESTLIST      = YES
 
 # The GENERATE_BUGLIST tag can be used to enable (YES) or
 # disable (NO) the bug list. This list is created by putting \bug
 # commands in the documentation.
 
 GENERATE_BUGLIST       = @MITK_DOXYGEN_GENERATE_BUGLIST@
 
 # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
 # disable (NO) the deprecated list. This list is created by putting
 # \deprecated commands in the documentation.
 
 GENERATE_DEPRECATEDLIST= @MITK_DOXYGEN_GENERATE_DEPRECATEDLIST@
 
 # The ENABLED_SECTIONS tag can be used to enable conditional
 # documentation sections, marked by \if sectionname ... \endif.
 
 ENABLED_SECTIONS       = @MITK_DOXYGEN_ENABLED_SECTIONS@
 
 # The MAX_INITIALIZER_LINES tag determines the maximum number of lines
 # the initial value of a variable or macro consists of for it to appear in
 # the documentation. If the initializer consists of more lines than specified
 # here it will be hidden. Use a value of 0 to hide initializers completely.
 # The appearance of the initializer of individual variables and macros in the
 # documentation can be controlled using \showinitializer or \hideinitializer
 # command in the documentation regardless of this setting.
 
 MAX_INITIALIZER_LINES  = 0
 
 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated
 # at the bottom of the documentation of classes and structs. If set to YES the
 # list will mention the files that were used to generate the documentation.
 
 SHOW_USED_FILES        = YES
 
 # If the sources in your project are distributed over multiple directories
 # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
 # in the documentation. The default is NO.
 
 SHOW_DIRECTORIES       = NO
 
 # Set the SHOW_FILES tag to NO to disable the generation of the Files page.
 # This will remove the Files entry from the Quick Index and from the
 # Folder Tree View (if specified). The default is YES.
 
 SHOW_FILES             = YES
 
 # Set the SHOW_NAMESPACES tag to NO to disable the generation of the
 # Namespaces page.
 # This will remove the Namespaces entry from the Quick Index
 # and from the Folder Tree View (if specified). The default is YES.
 
 SHOW_NAMESPACES        = YES
 
 # The FILE_VERSION_FILTER tag can be used to specify a program or script that
 # doxygen should invoke to get the current version for each file (typically from
 # the version control system). Doxygen will invoke the program by executing (via
 # popen()) the command <command> <input-file>, where <command> is the value of
 # the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
 # provided by doxygen. Whatever the program writes to standard output
 # is used as the file version. See the manual for examples.
 
 FILE_VERSION_FILTER    =
 
 # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
 # by doxygen. The layout file controls the global structure of the generated
 # output files in an output format independent way. The create the layout file
 # that represents doxygen's defaults, run doxygen with the -l option.
 # You can optionally specify a file name after the option, if omitted
 # DoxygenLayout.xml will be used as the name of the layout file.
 
-LAYOUT_FILE            =
+LAYOUT_FILE            = @MITK_SOURCE_DIR@/Documentation/MITKDoxygenLayout.xml
 
 # The CITE_BIB_FILES tag can be used to specify one or more bib files
 # containing the references data. This must be a list of .bib files. The
 # .bib extension is automatically appended if omitted. Using this command
 # requires the bibtex tool to be installed. See also
 # http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
 # of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
 # feature you need bibtex and perl available in the search path.
 
 CITE_BIB_FILES         =
 
 #---------------------------------------------------------------------------
 # configuration options related to warning and progress messages
 #---------------------------------------------------------------------------
 
 # The QUIET tag can be used to turn on/off the messages that are generated
 # by doxygen. Possible values are YES and NO. If left blank NO is used.
 
 QUIET                  = NO
 
 # The WARNINGS tag can be used to turn on/off the warning messages that are
 # generated by doxygen. Possible values are YES and NO. If left blank
 # NO is used.
 
 WARNINGS               = YES
 
 # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
 # for undocumented members. If EXTRACT_ALL is set to YES then this flag will
 # automatically be disabled.
 
 WARN_IF_UNDOCUMENTED   = YES
 
 # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
 # potential errors in the documentation, such as not documenting some
 # parameters in a documented function, or documenting parameters that
 # don't exist or using markup commands wrongly.
 
 WARN_IF_DOC_ERROR      = YES
 
 # The WARN_NO_PARAMDOC option can be enabled to get warnings for
 # functions that are documented, but have no documentation for their parameters
 # or return value. If set to NO (the default) doxygen will only warn about
 # wrong or incomplete parameter documentation, but not about the absence of
 # documentation.
 
 WARN_NO_PARAMDOC       = NO
 
 # The WARN_FORMAT tag determines the format of the warning messages that
 # doxygen can produce. The string should contain the $file, $line, and $text
 # tags, which will be replaced by the file and line number from which the
 # warning originated and the warning text. Optionally the format may contain
 # $version, which will be replaced by the version of the file (if it could
 # be obtained via FILE_VERSION_FILTER)
 
 WARN_FORMAT            = "$file:$line: $text"
 
 # The WARN_LOGFILE tag can be used to specify a file to which warning
 # and error messages should be written. If left blank the output is written
 # to stderr.
 
 WARN_LOGFILE           =
 
 #---------------------------------------------------------------------------
 # configuration options related to the input files
 #---------------------------------------------------------------------------
 
 # The INPUT tag can be used to specify the files and/or directories that contain
 # documented source files. You may enter file names like "myfile.cpp" or
 # directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 
 INPUT                  = @MITK_SOURCE_DIR@ \
                          @MITK_BINARY_DIR@ \
                          @MITK_DOXYGEN_ADDITIONAL_INPUT_DIRS@
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
 # also the default input encoding. Doxygen uses libiconv (or the iconv built
 # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
 # the list of possible encodings.
 
 INPUT_ENCODING         = UTF-8
 
 # If the value of the INPUT tag contains directories, you can use the
 # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
 # and *.h) to filter out the source-files in the directories. If left
 # blank the following patterns are tested:
 # *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
 # *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
 # *.f90 *.f *.for *.vhd *.vhdl
 
 FILE_PATTERNS          = *.h \
                          *.cpp \
                          *.dox \
                          *.md \
                          *.txx \
                          *.tpp \
                          *.cxx \
                          *.cmake
 
 # The RECURSIVE tag can be used to turn specify whether or not subdirectories
 # should be searched for input files as well. Possible values are YES and NO.
 # If left blank NO is used.
 
 RECURSIVE              = YES
 
 # The EXCLUDE tag can be used to specify files and/or directories that should be
 # excluded from the INPUT source files. This way you can easily exclude a
 # subdirectory from a directory tree whose root is specified with the INPUT tag.
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
 EXCLUDE                = @MITK_SOURCE_DIR@/Utilities/ann/ \
                          @MITK_SOURCE_DIR@/Utilities/glew/ \
                          @MITK_SOURCE_DIR@/Utilities/ipFunc/ \
                          @MITK_SOURCE_DIR@/Utilities/ipSegmentation/ \
                          @MITK_SOURCE_DIR@/Utilities/KWStyle/ \
                          @MITK_SOURCE_DIR@/Utilities/pic2vtk/ \
                          @MITK_SOURCE_DIR@/Utilities/Poco/ \
                          @MITK_SOURCE_DIR@/Utilities/qtsingleapplication/ \
                          @MITK_SOURCE_DIR@/Utilities/qwt/ \
                          @MITK_SOURCE_DIR@/Utilities/qxt/ \
                          @MITK_SOURCE_DIR@/Utilities/tinyxml/ \
                          @MITK_SOURCE_DIR@/Utilities/vecmath/ \
                          @MITK_SOURCE_DIR@/Applications/PluginGenerator/ \
                          @MITK_SOURCE_DIR@/BlueBerry/ \
                          @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/README.md \
                          @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/documentation/snippets/ \
                          @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/documentation/doxygen/standalone/ \
                          @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/test/ \
                          @MITK_SOURCE_DIR@/Deprecated/ \
                          @MITK_SOURCE_DIR@/Build/ \
                          @MITK_SOURCE_DIR@/CMake/PackageDepends \
                          @MITK_SOURCE_DIR@/CMake/QBundleTemplate \
                          @MITK_SOURCE_DIR@/CMakeExternals \
                          @MITK_SOURCE_DIR@/Modules/QmitkExt/vtkQtChartHeaders/ \
                          @MITK_BINARY_DIR@/PT/ \
                          @MITK_BINARY_DIR@/GP/ \
                          @MITK_BINARY_DIR@/Core/Code/CppMicroServices/ \
                          @MITK_DOXYGEN_ADDITIONAL_EXCLUDE_DIRS@
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
 # from the input.
 
 EXCLUDE_SYMLINKS       = NO
 
 # If the value of the INPUT tag contains directories, you can use the
 # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
 # certain files from those directories. Note that the wildcards are matched
 # against the file with absolute path, so to exclude all test directories
 # for example use the pattern */test/*
 
 EXCLUDE_PATTERNS       = moc_* \
                          Register* \
                          */files.cmake \
                          */.git/* \
                          *_p.h \
                          *Private.* \
                          */Snippets/* \
                          */snippets/* \
                          */testing/* \
                          */Testing/* \
                          @MITK_BINARY_DIR@/*.cmake \
                          @MITK_DOXYGEN_EXCLUDE_PATTERNS@
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 # (namespaces, classes, functions, etc.) that should be excluded from the
 # output. The symbol name can be a fully qualified name, a word, or if the
 # wildcard * is used, a substring. Examples: ANamespace, AClass,
 # AClass::ANamespace, ANamespace::*Test
 
 EXCLUDE_SYMBOLS        =
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or
 # directories that contain example code fragments that are included (see
 # the \include command).
 
 EXAMPLE_PATH           = @MITK_SOURCE_DIR@/Examples/ \
                          @MITK_SOURCE_DIR@/Examples/Tutorial/ \
                          @MITK_SOURCE_DIR@/Examples/QtFreeRender/ \
                          @MITK_SOURCE_DIR@/Core/Code/ \
                          @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/Documentation/Snippets/ \
                          @MITK_DOXYGEN_OUTPUT_DIR@/html/extension-points/html/ \
                          @MITK_SOURCE_DIR@/Documentation/Snippets/ \
                          @MITK_SOURCE_DIR@/Documentation/Doxygen/ExampleCode/
 
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
 # and *.h) to filter out the source-files in the directories. If left
 # blank all files are included.
 
 EXAMPLE_PATTERNS       =
 
 # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
 # searched for input files to be used with the \include or \dontinclude
 # commands irrespective of the value of the RECURSIVE tag.
 # Possible values are YES and NO. If left blank NO is used.
 
 EXAMPLE_RECURSIVE      = YES
 
 # The IMAGE_PATH tag can be used to specify one or more files or
 # directories that contain image that are included in the documentation (see
 # the \image command).
 
 IMAGE_PATH             = @MITK_SOURCE_DIR@/Documentation/Doxygen/ \
                          @MITK_SOURCE_DIR@/Documentation/Doxygen/Modules/ \
                          @MITK_SOURCE_DIR@/Documentation/Doxygen/Tutorial/ \
                          @MITK_SOURCE_DIR@
 
 # The INPUT_FILTER tag can be used to specify a program that doxygen should
 # invoke to filter for each input file. Doxygen will invoke the filter program
 # by executing (via popen()) the command <filter> <input-file>, where <filter>
 # is the value of the INPUT_FILTER tag, and <input-file> is the name of an
 # input file. Doxygen will then use the output that the filter program writes
 # to standard output.
 # If FILTER_PATTERNS is specified, this tag will be
 # ignored.
 
 INPUT_FILTER           =
 
 # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
 # basis.
 # Doxygen will compare the file name with each pattern and apply the
 # filter if there is a match.
 # The filters are a list of the form:
 # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
 # info on how filters are used. If FILTER_PATTERNS is empty or if
 # non of the patterns match the file name, INPUT_FILTER is applied.
 
 FILTER_PATTERNS        = *.cmake=@CMakeDoxygenFilter_EXECUTABLE@
 
 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
 # INPUT_FILTER) will be used to filter the input files when producing source
 # files to browse (i.e. when SOURCE_BROWSER is set to YES).
 
 FILTER_SOURCE_FILES    = NO
 
 # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
 # pattern. A pattern will override the setting for FILTER_PATTERN (if any)
 # and it is also possible to disable source filtering for a specific pattern
 # using *.ext= (so without naming a filter). This option only has effect when
 # FILTER_SOURCE_FILES is enabled.
 
 FILTER_SOURCE_PATTERNS =
 
 #---------------------------------------------------------------------------
 # configuration options related to source browsing
 #---------------------------------------------------------------------------
 
 # If the SOURCE_BROWSER tag is set to YES then a list of source files will
 # be generated. Documented entities will be cross-referenced with these sources.
 # Note: To get rid of all source code in the generated output, make sure also
 # VERBATIM_HEADERS is set to NO.
 
 SOURCE_BROWSER         = YES
 
 # Setting the INLINE_SOURCES tag to YES will include the body
 # of functions and classes directly in the documentation.
 
 INLINE_SOURCES         = NO
 
 # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
 # doxygen to hide any special comment blocks from generated source code
 # fragments. Normal C and C++ comments will always remain visible.
 
 STRIP_CODE_COMMENTS    = YES
 
 # If the REFERENCED_BY_RELATION tag is set to YES
 # then for each documented function all documented
 # functions referencing it will be listed.
 
 REFERENCED_BY_RELATION = YES
 
 # If the REFERENCES_RELATION tag is set to YES
 # then for each documented function all documented entities
 # called/used by that function will be listed.
 
 REFERENCES_RELATION    = YES
 
 # If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
 # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
 # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
 # link to the source code.
 # Otherwise they will link to the documentation.
 
 REFERENCES_LINK_SOURCE = YES
 
 # If the USE_HTAGS tag is set to YES then the references to source code
 # will point to the HTML generated by the htags(1) tool instead of doxygen
 # built-in source browser. The htags tool is part of GNU's global source
 # tagging system (see http://www.gnu.org/software/global/global.html). You
 # will need version 4.8.6 or higher.
 
 USE_HTAGS              = NO
 
 # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
 # will generate a verbatim copy of the header file for each class for
 # which an include is specified. Set to NO to disable this.
 
 VERBATIM_HEADERS       = YES
 
 #---------------------------------------------------------------------------
 # configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
 
 # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
 # of all compounds will be generated. Enable this if the project
 # contains a lot of classes, structs, unions or interfaces.
 
 ALPHABETICAL_INDEX     = YES
 
 # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
 # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
 # in which this list will be split (can be a number in the range [1..20])
 
 COLS_IN_ALPHA_INDEX    = 3
 
 # In case all classes in a project start with a common prefix, all
 # classes will be put under the same header in the alphabetical index.
 # The IGNORE_PREFIX tag can be used to specify one or more prefixes that
 # should be ignored while generating the index headers.
 
 IGNORE_PREFIX          =
 
 #---------------------------------------------------------------------------
 # configuration options related to the HTML output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_HTML tag is set to YES (the default) Doxygen will
 # generate HTML output.
 
 GENERATE_HTML          = YES
 
 # The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `html' will be used as the default path.
 
 HTML_OUTPUT            = html
 
 # The HTML_FILE_EXTENSION tag can be used to specify the file extension for
 # each generated HTML page (for example: .htm,.php,.asp). If it is left blank
 # doxygen will generate files with .html extension.
 
 HTML_FILE_EXTENSION    = .html
 
 # The HTML_HEADER tag can be used to specify a personal HTML header for
 # each generated HTML page. If it is left blank doxygen will generate a
 # standard header. Note that when using a custom header you are responsible
 #  for the proper inclusion of any scripts and style sheets that doxygen
 # needs, which is dependent on the configuration options used.
 # It is advised to generate a default header using "doxygen -w html
 # header.html footer.html stylesheet.css YourConfigFile" and then modify
 # that header. Note that the header is subject to change so you typically
 # have to redo this when upgrading to a newer version of doxygen or when
 # changing the value of configuration settings such as GENERATE_TREEVIEW!
 
 HTML_HEADER            =
 
 # The HTML_FOOTER tag can be used to specify a personal HTML footer for
 # each generated HTML page. If it is left blank doxygen will generate a
 # standard footer.
 
 HTML_FOOTER            =
 
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading
 # style sheet that is used by each HTML page. It can be used to
 # fine-tune the look of the HTML output. If the tag is left blank doxygen
 # will generate a default style sheet. Note that doxygen will try to copy
 # the style sheet file to the HTML output directory, so don't put your own
 # style sheet in the HTML output directory as well, or it will be erased!
 
 HTML_STYLESHEET        = @MITK_DOXYGEN_STYLESHEET@
 
 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the HTML output directory. Note
 # that these files will be copied to the base HTML output directory. Use the
 # $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
 # files. In the HTML_STYLESHEET file, use the file name only. Also note that
 # the files will be copied as-is; there are no commands or markers available.
 
 HTML_EXTRA_FILES       =
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
 # Doxygen will adjust the colors in the style sheet and background images
 # according to this color. Hue is specified as an angle on a colorwheel,
 # see http://en.wikipedia.org/wiki/Hue for more information.
 # For instance the value 0 represents red, 60 is yellow, 120 is green,
 # 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
 # The allowed range is 0 to 359.
 
 HTML_COLORSTYLE_HUE    = 220
 
 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
 # the colors in the HTML output. For a value of 0 the output will use
 # grayscales only. A value of 255 will produce the most vivid colors.
 
 HTML_COLORSTYLE_SAT    = 100
 
 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
 # the luminance component of the colors in the HTML output. Values below
 # 100 gradually make the output lighter, whereas values above 100 make
 # the output darker. The value divided by 100 is the actual gamma applied,
 # so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
 # and 100 does not change the gamma.
 
 HTML_COLORSTYLE_GAMMA  = 80
 
 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
 # page will contain the date and time when the page was generated. Setting
 # this to NO can help when comparing the output of multiple runs.
 
 HTML_TIMESTAMP         = YES
 
 # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
 # files or namespaces will be aligned in HTML using tables. If set to
 # NO a bullet list will be used.
 
 HTML_ALIGN_MEMBERS     = YES
 
 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 # documentation will contain sections that can be hidden and shown after the
 # page has loaded. For this to work a browser that supports
 # JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
 # Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
 
 HTML_DYNAMIC_SECTIONS  = @MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS@
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files
 # will be generated that can be used as input for Apple's Xcode 3
 # integrated development environment, introduced with OSX 10.5 (Leopard).
 # To create a documentation set, doxygen will generate a Makefile in the
 # HTML output directory. Running make will produce the docset in that
 # directory and running "make install" will install the docset in
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
 # it at startup.
 # See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
 # for more information.
 
 GENERATE_DOCSET        = NO
 
 # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
 # feed. A documentation feed provides an umbrella under which multiple
 # documentation sets from a single provider (such as a company or product suite)
 # can be grouped.
 
 DOCSET_FEEDNAME        = "Doxygen generated docs"
 
 # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
 # should uniquely identify the documentation set bundle. This should be a
 # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
 # will append .docset to the name.
 
 DOCSET_BUNDLE_ID       = org.doxygen.Project
 
 # When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
 # the documentation publisher. This should be a reverse domain-name style
 # string, e.g. com.mycompany.MyDocSet.documentation.
 
 DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
 
 # The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
 
 DOCSET_PUBLISHER_NAME  = Publisher
 
 # If the GENERATE_HTMLHELP tag is set to YES, additional index files
 # will be generated that can be used as input for tools like the
 # Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
 # of the generated HTML documentation.
 
 GENERATE_HTMLHELP      = NO
 
 # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
 # be used to specify the file name of the resulting .chm file. You
 # can add a path in front of the file if the result should not be
 # written to the html output directory.
 
 CHM_FILE               =
 
 # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
 # be used to specify the location (absolute path including file name) of
 # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
 # the HTML help compiler on the generated index.hhp.
 
 HHC_LOCATION           =
 
 # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
 # controls if a separate .chi index file is generated (YES) or that
 # it should be included in the master .chm file (NO).
 
 GENERATE_CHI           = NO
 
 # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
 # is used to encode HtmlHelp index (hhk), content (hhc) and project file
 # content.
 
 CHM_INDEX_ENCODING     =
 
 # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
 # controls whether a binary table of contents is generated (YES) or a
 # normal table of contents (NO) in the .chm file.
 
 BINARY_TOC             = NO
 
 # The TOC_EXPAND flag can be set to YES to add extra items for group members
 # to the contents of the HTML help documentation and to the tree view.
 
 TOC_EXPAND             = NO
 
 # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
 # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
 # that can be used as input for Qt's qhelpgenerator to generate a
 # Qt Compressed Help (.qch) of the generated HTML documentation.
 
 GENERATE_QHP           = @MITK_DOXYGEN_GENERATE_QHP@
 
 # If the QHG_LOCATION tag is specified, the QCH_FILE tag can
 # be used to specify the file name of the resulting .qch file.
 # The path specified is relative to the HTML output folder.
 
 QCH_FILE               = @MITK_DOXYGEN_QCH_FILE@
 
 # The QHP_NAMESPACE tag specifies the namespace to use when generating
 # Qt Help Project output. For more information please see
 # http://doc.trolltech.com/qthelpproject.html#namespace
 
 QHP_NAMESPACE          = "org.mitk"
 
 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
 # Qt Help Project output. For more information please see
 # http://doc.trolltech.com/qthelpproject.html#virtual-folders
 
 QHP_VIRTUAL_FOLDER     = MITK
 
 # If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
 # add. For more information please see
 # http://doc.trolltech.com/qthelpproject.html#custom-filters
 
 QHP_CUST_FILTER_NAME   =
 
 # The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
 # custom filter to add. For more information please see
 # <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
 # Qt Help Project / Custom Filters</a>.
 
 QHP_CUST_FILTER_ATTRS  =
 
 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
 # project's
 # filter section matches.
 # <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
 # Qt Help Project / Filter Attributes</a>.
 
 QHP_SECT_FILTER_ATTRS  =
 
 # If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
 # be used to specify the location of Qt's qhelpgenerator.
 # If non-empty doxygen will try to run qhelpgenerator on the generated
 # .qhp file.
 
 QHG_LOCATION           = @QT_HELPGENERATOR_EXECUTABLE@
 
 # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
 #  will be generated, which together with the HTML files, form an Eclipse help
 # plugin. To install this plugin and make it available under the help contents
 # menu in Eclipse, the contents of the directory containing the HTML and XML
 # files needs to be copied into the plugins directory of eclipse. The name of
 # the directory within the plugins directory should be the same as
 # the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
 # the help appears.
 
 GENERATE_ECLIPSEHELP   = NO
 
 # A unique identifier for the eclipse help plugin. When installing the plugin
 # the directory name containing the HTML and XML files should also have
 # this name.
 
 ECLIPSE_DOC_ID         = org.doxygen.Project
 
 # The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
 # at top of each HTML page. The value NO (the default) enables the index and
 # the value YES disables it. Since the tabs have the same information as the
 # navigation tree you can set this option to NO if you already set
 # GENERATE_TREEVIEW to YES.
 
 DISABLE_INDEX          = NO
 
 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
 # structure should be generated to display hierarchical information.
 # If the tag value is set to YES, a side panel will be generated
 # containing a tree-like index structure (just like the one that
 # is generated for HTML Help). For this to work a browser that supports
 # JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
 # Windows users are probably better off using the HTML help feature.
 # Since the tree basically has the same information as the tab index you
 # could consider to set DISABLE_INDEX to NO when enabling this option.
 
 GENERATE_TREEVIEW      = YES
 
 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
 # (range [0,1..20]) that doxygen will group on one line in the generated HTML
 # documentation. Note that a value of 0 will completely suppress the enum
 # values from appearing in the overview section.
 
 ENUM_VALUES_PER_LINE   = 4
 
 # By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
 # and Class Hierarchy pages using a tree view instead of an ordered list.
 
 USE_INLINE_TREES       = NO
 
 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
 # used to set the initial width (in pixels) of the frame in which the tree
 # is shown.
 
 TREEVIEW_WIDTH         = 300
 
 # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
 # links to external symbols imported via tag files in a separate window.
 
 EXT_LINKS_IN_WINDOW    = NO
 
 # Use this tag to change the font size of Latex formulas included
 # as images in the HTML documentation. The default is 10. Note that
 # when you change the font size after a successful doxygen run you need
 # to manually remove any form_*.png images from the HTML output directory
 # to force them to be regenerated.
 
 FORMULA_FONTSIZE       = 10
 
 # Use the FORMULA_TRANPARENT tag to determine whether or not the images
 # generated for formulas are transparent PNGs. Transparent PNGs are
 # not supported properly for IE 6.0, but are supported on all modern browsers.
 # Note that when changing this option you need to delete any form_*.png files
 # in the HTML output before the changes have effect.
 
 FORMULA_TRANSPARENT    = YES
 
 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
 # (see http://www.mathjax.org) which uses client side Javascript for the
 # rendering instead of using prerendered bitmaps. Use this if you do not
 # have LaTeX installed or if you want to formulas look prettier in the HTML
 # output. When enabled you may also need to install MathJax separately and
 # configure the path to it using the MATHJAX_RELPATH option.
 
 USE_MATHJAX            = NO
 
 # When MathJax is enabled you need to specify the location relative to the
 # HTML output directory using the MATHJAX_RELPATH option. The destination
 # directory should contain the MathJax.js script. For instance, if the mathjax
 # directory is located at the same level as the HTML output directory, then
 # MATHJAX_RELPATH should be ../mathjax. The default value points to
 # the MathJax Content Delivery Network so you can quickly see the result without
 # installing MathJax.
 # However, it is strongly recommended to install a local
 # copy of MathJax from http://www.mathjax.org before deployment.
 
 MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
 
 # The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
 # names that should be enabled during MathJax rendering.
 
 MATHJAX_EXTENSIONS     =
 
 # When the SEARCHENGINE tag is enabled doxygen will generate a search box
 # for the HTML output. The underlying search engine uses javascript
 # and DHTML and should work on any modern browser. Note that when using
 # HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
 # (GENERATE_DOCSET) there is already a search function so this one should
 # typically be disabled. For large projects the javascript based search engine
 # can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
 
 SEARCHENGINE           = YES
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
 # implemented using a PHP enabled web server instead of at the web client
 # using Javascript. Doxygen will generate the search PHP script and index
 # file to put on the web server. The advantage of the server
 # based approach is that it scales better to large projects and allows
 # full text search. The disadvantages are that it is more difficult to setup
 # and does not have live searching capabilities.
 
 SERVER_BASED_SEARCH    = NO
 
 #---------------------------------------------------------------------------
 # configuration options related to the LaTeX output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
 # generate Latex output.
 
 GENERATE_LATEX         = NO
 
 # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `latex' will be used as the default path.
 
 LATEX_OUTPUT           = latex
 
 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
 # invoked. If left blank `latex' will be used as the default command name.
 # Note that when enabling USE_PDFLATEX this option is only used for
 # generating bitmaps for formulas in the HTML output, but not in the
 # Makefile that is written to the output directory.
 
 LATEX_CMD_NAME         = latex
 
 # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
 # generate index for LaTeX. If left blank `makeindex' will be used as the
 # default command name.
 
 MAKEINDEX_CMD_NAME     = makeindex
 
 # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
 # LaTeX documents. This may be useful for small projects and may help to
 # save some trees in general.
 
 COMPACT_LATEX          = NO
 
 # The PAPER_TYPE tag can be used to set the paper type that is used
 # by the printer. Possible values are: a4, letter, legal and
 # executive. If left blank a4wide will be used.
 
 PAPER_TYPE             = a4wide
 
 # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
 # packages that should be included in the LaTeX output.
 
 EXTRA_PACKAGES         = amssymb
 
 # The LATEX_HEADER tag can be used to specify a personal LaTeX header for
 # the generated latex document. The header should contain everything until
 # the first chapter. If it is left blank doxygen will generate a
 # standard header. Notice: only use this tag if you know what you are doing!
 
 LATEX_HEADER           =
 
 # The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
 # the generated latex document. The footer should contain everything after
 # the last chapter. If it is left blank doxygen will generate a
 # standard footer. Notice: only use this tag if you know what you are doing!
 
 LATEX_FOOTER           =
 
 # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
 # is prepared for conversion to pdf (using ps2pdf). The pdf file will
 # contain links (just like the HTML output) instead of page references
 # This makes the output suitable for online browsing using a pdf viewer.
 
 PDF_HYPERLINKS         = NO
 
 # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
 # plain latex in the generated Makefile. Set this option to YES to get a
 # higher quality PDF documentation.
 
 USE_PDFLATEX           = NO
 
 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
 # command to the generated LaTeX files. This will instruct LaTeX to keep
 # running if errors occur, instead of asking the user for help.
 # This option is also used when generating formulas in HTML.
 
 LATEX_BATCHMODE        = NO
 
 # If LATEX_HIDE_INDICES is set to YES then doxygen will not
 # include the index chapters (such as File Index, Compound Index, etc.)
 # in the output.
 
 LATEX_HIDE_INDICES     = NO
 
 # If LATEX_SOURCE_CODE is set to YES then doxygen will include
 # source code with syntax highlighting in the LaTeX output.
 # Note that which sources are shown also depends on other settings
 # such as SOURCE_BROWSER.
 
 LATEX_SOURCE_CODE      = NO
 
 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
 # bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
 # http://en.wikipedia.org/wiki/BibTeX for more info.
 
 LATEX_BIB_STYLE        = plain
 
 #---------------------------------------------------------------------------
 # configuration options related to the RTF output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
 # The RTF output is optimized for Word 97 and may not look very pretty with
 # other RTF readers or editors.
 
 GENERATE_RTF           = NO
 
 # The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `rtf' will be used as the default path.
 
 RTF_OUTPUT             = rtf
 
 # If the COMPACT_RTF tag is set to YES Doxygen generates more compact
 # RTF documents. This may be useful for small projects and may help to
 # save some trees in general.
 
 COMPACT_RTF            = NO
 
 # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
 # will contain hyperlink fields. The RTF file will
 # contain links (just like the HTML output) instead of page references.
 # This makes the output suitable for online browsing using WORD or other
 # programs which support those fields.
 # Note: wordpad (write) and others do not support links.
 
 RTF_HYPERLINKS         = NO
 
 # Load style sheet definitions from file. Syntax is similar to doxygen's
 # config file, i.e. a series of assignments. You only have to provide
 # replacements, missing definitions are set to their default value.
 
 RTF_STYLESHEET_FILE    =
 
 # Set optional variables used in the generation of an rtf document.
 # Syntax is similar to doxygen's config file.
 
 RTF_EXTENSIONS_FILE    =
 
 #---------------------------------------------------------------------------
 # configuration options related to the man page output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_MAN tag is set to YES (the default) Doxygen will
 # generate man pages
 
 GENERATE_MAN           = NO
 
 # The MAN_OUTPUT tag is used to specify where the man pages will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `man' will be used as the default path.
 
 MAN_OUTPUT             = man
 
 # The MAN_EXTENSION tag determines the extension that is added to
 # the generated man pages (default is the subroutine's section .3)
 
 MAN_EXTENSION          = .3
 
 # If the MAN_LINKS tag is set to YES and Doxygen generates man output,
 # then it will generate one additional man file for each entity
 # documented in the real man page(s). These additional files
 # only source the real man page, but without them the man command
 # would be unable to find the correct page. The default is NO.
 
 MAN_LINKS              = NO
 
 #---------------------------------------------------------------------------
 # configuration options related to the XML output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_XML tag is set to YES Doxygen will
 # generate an XML file that captures the structure of
 # the code including all documentation.
 
 GENERATE_XML           = NO
 
 # The XML_OUTPUT tag is used to specify where the XML pages will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 # put in front of it. If left blank `xml' will be used as the default path.
 
 XML_OUTPUT             = xml
 
 # The XML_SCHEMA tag can be used to specify an XML schema,
 # which can be used by a validating XML parser to check the
 # syntax of the XML files.
 
 XML_SCHEMA             =
 
 # The XML_DTD tag can be used to specify an XML DTD,
 # which can be used by a validating XML parser to check the
 # syntax of the XML files.
 
 XML_DTD                =
 
 # If the XML_PROGRAMLISTING tag is set to YES Doxygen will
 # dump the program listings (including syntax highlighting
 # and cross-referencing information) to the XML output. Note that
 # enabling this will significantly increase the size of the XML output.
 
 XML_PROGRAMLISTING     = YES
 
 #---------------------------------------------------------------------------
 # configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
 # generate an AutoGen Definitions (see autogen.sf.net) file
 # that captures the structure of the code including all
 # documentation. Note that this feature is still experimental
 # and incomplete at the moment.
 
 GENERATE_AUTOGEN_DEF   = NO
 
 #---------------------------------------------------------------------------
 # configuration options related to the Perl module output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_PERLMOD tag is set to YES Doxygen will
 # generate a Perl module file that captures the structure of
 # the code including all documentation. Note that this
 # feature is still experimental and incomplete at the
 # moment.
 
 GENERATE_PERLMOD       = NO
 
 # If the PERLMOD_LATEX tag is set to YES Doxygen will generate
 # the necessary Makefile rules, Perl scripts and LaTeX code to be able
 # to generate PDF and DVI output from the Perl module output.
 
 PERLMOD_LATEX          = NO
 
 # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
 # nicely formatted so it can be parsed by a human reader.
 # This is useful
 # if you want to understand what is going on.
 # On the other hand, if this
 # tag is set to NO the size of the Perl module output will be much smaller
 # and Perl will parse it just the same.
 
 PERLMOD_PRETTY         = YES
 
 # The names of the make variables in the generated doxyrules.make file
 # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
 # This is useful so different doxyrules.make files included by the same
 # Makefile don't overwrite each other's variables.
 
 PERLMOD_MAKEVAR_PREFIX =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the preprocessor
 #---------------------------------------------------------------------------
 
 # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
 # evaluate all C-preprocessor directives found in the sources and include
 # files.
 
 ENABLE_PREPROCESSING   = YES
 
 # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
 # names in the source code. If set to NO (the default) only conditional
 # compilation will be performed. Macro expansion can be done in a controlled
 # way by setting EXPAND_ONLY_PREDEF to YES.
 
 MACRO_EXPANSION        = YES
 
 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
 # then the macro expansion is limited to the macros specified with the
 # PREDEFINED and EXPAND_AS_DEFINED tags.
 
 EXPAND_ONLY_PREDEF     = NO
 
 # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
 # pointed to by INCLUDE_PATH will be searched when a #include is found.
 
 SEARCH_INCLUDES        = YES
 
 # The INCLUDE_PATH tag can be used to specify one or more directories that
 # contain include files that are not input files but should be processed by
 # the preprocessor.
 
 INCLUDE_PATH           =
 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
 # patterns (like *.h and *.hpp) to filter out the header-files in the
 # directories. If left blank, the patterns specified with FILE_PATTERNS will
 # be used.
 
 INCLUDE_FILE_PATTERNS  =
 
 # The PREDEFINED tag can be used to specify one or more macro names that
 # are defined before the preprocessor is started (similar to the -D option of
 # gcc). The argument of the tag is a list of macros of the form: name
 # or name=definition (no spaces). If the definition and the = are
 # omitted =1 is assumed. To prevent a macro definition from being
 # undefined via #undef or recursively expanded use the := operator
 # instead of the = operator.
 
 PREDEFINED             = itkNotUsed(x)= \
                          "itkSetMacro(name,type)=                   virtual void Set##name (type _arg);" \
                          "itkGetMacro(name,type)=                   virtual type Get##name ();" \
                          "itkGetConstMacro(name,type)=                   virtual type Get##name () const;" \
                          "itkSetStringMacro(name)=                   virtual void Set##name (const char* _arg);" \
                          "itkGetStringMacro(name)=                   virtual const char* Get##name () const;" \
                          "itkSetClampMacro(name,type,min,max)=                   virtual void Set##name (type _arg);" \
                          "itkSetObjectMacro(name,type)=                   virtual void Set##name (type* _arg);" \
                          "itkGetObjectMacro(name,type)=                   virtual type* Get##name ();" \
                          "itkSetConstObjectMacro(name,type)=                   virtual void Set##name ( const type* _arg);" \
                          "itkGetConstObjectMacro(name,type)=                   virtual const type* Get##name ();" \
                          "itkGetConstReferenceMacro(name,type)=                   virtual const type& Get##name ();" \
                          "itkGetConstReferenceObjectMacro(name,type)=                   virtual const type::Pointer& Get##name () const;" \
                          "itkBooleanMacro(name)=                   virtual void name##On ();                   virtual void name##Off ();" \
                          "itkSetVector2Macro(name,type)=                   virtual void Set##name (type _arg1, type _arg2)                   virtual void Set##name (type _arg[2]);" \
                          "itkGetVector2Macro(name,type)=                   virtual type* Get##name () const;                   virtual void Get##name (type& _arg1, type& _arg2) const;                   virtual void Get##name (type _arg[2]) const;" \
                          "itkSetVector3Macro(name,type)=                   virtual void Set##name (type _arg1, type _arg2, type _arg3)                   virtual void Set##name (type _arg[3]);" \
                          "itkGetVector3Macro(name,type)=                   virtual type* Get##name () const;                   virtual void Get##name (type& _arg1, type& _arg2, type& _arg3) const;                   virtual void Get##name (type _arg[3]) const;" \
                          "itkSetVector4Macro(name,type)=                   virtual void Set##name (type _arg1, type _arg2, type _arg3, type _arg4)                   virtual void Set##name (type _arg[4]);" \
                          "itkGetVector4Macro(name,type)=                   virtual type* Get##name () const;                   virtual void Get##name (type& _arg1, type& _arg2, type& _arg3, type& _arg4) const;                   virtual void Get##name (type _arg[4]) const;" \
                          "itkSetVector6Macro(name,type)=                   virtual void Set##name (type _arg1, type _arg2, type _arg3, type _arg4, type _arg5, type _arg6)                   virtual void Set##name (type _arg[6]);" \
                          "itkGetVector6Macro(name,type)=                   virtual type* Get##name () const;                   virtual void Get##name (type& _arg1, type& _arg2, type& _arg3, type& _arg4, type& _arg5, type& _arg6) const;                   virtual void Get##name (type _arg[6]) const;" \
                          "itkSetVectorMacro(name,type,count)=                   virtual void Set##name(type data[]);" \
                          "itkGetVectorMacro(name,type,count)=                   virtual type* Get##name () const;" \
                          "itkNewMacro(type)=                   static Pointer New();" \
                          "itkTypeMacro(thisClass,superclass)=                   virtual const char *GetClassName() const;" \
                          "itkConceptMacro(name,concept)=                   enum { name = 0 };" \
                          "ITK_NUMERIC_LIMITS=                   std::numeric_limits" \
                          "ITK_TYPENAME=                   typename" \
                          "FEM_ABSTRACT_CLASS(thisClass,parentClass)=                   public:                                                                   /** Standard Self typedef.*/                                          typedef thisClass Self;                                                 /** Standard Superclass typedef. */                                   typedef parentClass Superclass;                                         /** Pointer or SmartPointer to an object. */                            typedef Self* Pointer;                                                  /** Const pointer or SmartPointer to an object. */                      typedef const Self* ConstPointer;                                     private:" \
                          "FEM_CLASS(thisClass,parentClass)=                   FEM_ABSTRACT_CLASS(thisClass,parentClass)                               public:                                                                   /** Create a new object from the existing one  */                       virtual Baseclass::Pointer Clone() const;                               /** Class ID for FEM object factory */                                  static const int CLID;                                                  /** Virtual function to access the class ID */                          virtual int ClassID() const                                               { return CLID; }                                                      /** Object creation in an itk compatible way */                         static Self::Pointer New()                                                { return new Self(); }                                              private:" \
                          FREEVERSION \
                          ERROR_CHECKING \
                          HAS_TIFF \
                          HAS_JPEG \
                          HAS_NETLIB \
                          HAS_PNG \
                          HAS_ZLIB \
                          HAS_GLUT \
                          HAS_QT \
                          VCL_USE_NATIVE_STL=1 \
                          VCL_USE_NATIVE_COMPLEX=1 \
                          VCL_HAS_BOOL=1 \
                          VXL_BIG_ENDIAN=1 \
                          VXL_LITTLE_ENDIAN=0 \
                          VNL_DLL_DATA= \
                          size_t=vcl_size_t \
                          "US_PREPEND_NAMESPACE(x)=mitk::x" \
                          "US_BEGIN_NAMESPACE= namespace mitk {" \
                          "US_END_NAMESPACE=}" \
                          "US_BASECLASS_NAME=itk::LightObject" \
-                         US_EXPORT=
+                         US_EXPORT= \
+                         "DEPRECATED(func)=func"
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
 # this tag can be used to specify a list of macro names that should be expanded.
 # The macro definition that is found in the sources will be used.
 # Use the PREDEFINED tag if you want to use a different macro definition that
 # overrules the definition found in the source code.
 
 EXPAND_AS_DEFINED      =
 
 # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
 # doxygen's preprocessor will remove all references to function-like macros
 # that are alone on a line, have an all uppercase name, and do not end with a
 # semicolon, because these will confuse the parser if not removed.
 
 SKIP_FUNCTION_MACROS   = YES
 
 #---------------------------------------------------------------------------
 # Configuration::additions related to external references
 #---------------------------------------------------------------------------
 
 # The TAGFILES option can be used to specify one or more tagfiles. For each
 # tag file the location of the external documentation should be added. The
 # format of a tag file without this location is as follows:
 #
 # TAGFILES = file1 file2 ...
 # Adding location for the tag files is done as follows:
 #
 # TAGFILES = file1=loc1 "file2 = loc2" ...
 # where "loc1" and "loc2" can be relative or absolute paths
 # or URLs. Note that each tag file must have a unique name (where the name does
 # NOT include the path). If a tag file is not located in the directory in which
 # doxygen is run, you must also specify the path to the tagfile here.
 
 TAGFILES               = @BLUEBERRY_DOXYGEN_TAGFILE@
 
 # When a file name is specified after GENERATE_TAGFILE, doxygen will create
 # a tag file that is based on the input files it reads.
 
 GENERATE_TAGFILE       = @MITK_DOXYGEN_TAGFILE_NAME@
 
 # If the ALLEXTERNALS tag is set to YES all external classes will be listed
 # in the class index. If set to NO only the inherited external classes
 # will be listed.
 
 ALLEXTERNALS           = NO
 
 # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
 # in the modules index. If set to NO, only the current project's groups will
 # be listed.
 
 EXTERNAL_GROUPS        = NO
 
 # The PERL_PATH should be the absolute path and name of the perl script
 # interpreter (i.e. the result of `which perl').
 
 PERL_PATH              = /usr/bin/perl
 
 #---------------------------------------------------------------------------
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
 # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
 # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
 # or super classes. Setting the tag to NO turns the diagrams off. Note that
 # this option also works with HAVE_DOT disabled, but it is recommended to
 # install and use dot, since it yields more powerful graphs.
 
 CLASS_DIAGRAMS         = YES
 
 # You can define message sequence charts within doxygen comments using the \msc
 # command. Doxygen will then run the mscgen tool (see
 # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
 # documentation. The MSCGEN_PATH tag allows you to specify the directory where
 # the mscgen tool resides. If left empty the tool is assumed to be found in the
 # default search path.
 
 MSCGEN_PATH            =
 
 # If set to YES, the inheritance and collaboration graphs will hide
 # inheritance and usage relations if the target is undocumented
 # or is not a class.
 
 HIDE_UNDOC_RELATIONS   = YES
 
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
 # available from the path. This tool is part of Graphviz, a graph visualization
 # toolkit from AT&T and Lucent Bell Labs. The other options in this section
 # have no effect if this option is set to NO (the default)
 
 HAVE_DOT               = @HAVE_DOT@
 
 # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
 # allowed to run in parallel. When set to 0 (the default) doxygen will
 # base this on the number of processors available in the system. You can set it
 # explicitly to a value larger than 0 to get control over the balance
 # between CPU load and processing speed.
 
 DOT_NUM_THREADS        = @MITK_DOXYGEN_DOT_NUM_THREADS@
 
 # By default doxygen will use the Helvetica font for all dot files that
 # doxygen generates. When you want a differently looking font you can specify
 # the font name using DOT_FONTNAME. You need to make sure dot is able to find
 # the font, which can be done by putting it in a standard location or by setting
 # the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
 # directory containing the font.
 
 DOT_FONTNAME           = FreeSans.ttf
 
 # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
 # The default size is 10pt.
 
 DOT_FONTSIZE           = 10
 
 # By default doxygen will tell dot to use the Helvetica font.
 # If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
 # set the path where dot can find it.
 
 DOT_FONTPATH           =
 
 # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
 # will generate a graph for each documented class showing the direct and
 # indirect inheritance relations. Setting this tag to YES will force the
 # CLASS_DIAGRAMS tag to NO.
 
 CLASS_GRAPH            = YES
 
 # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
 # will generate a graph for each documented class showing the direct and
 # indirect implementation dependencies (inheritance, containment, and
 # class references variables) of the class with other documented classes.
 
 COLLABORATION_GRAPH    = YES
 
 # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
 # will generate a graph for groups, showing the direct groups dependencies
 
 GROUP_GRAPHS           = YES
 
 # If the UML_LOOK tag is set to YES doxygen will generate inheritance and
 # collaboration diagrams in a style similar to the OMG's Unified Modeling
 # Language.
 
 UML_LOOK               = @MITK_DOXYGEN_UML_LOOK@
 
 # If the UML_LOOK tag is enabled, the fields and methods are shown inside
 # the class node. If there are many fields or methods and many nodes the
 # graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
 # threshold limits the number of items for each type to make the size more
 # managable. Set this to 0 for no limit. Note that the threshold may be
 # exceeded by 50% before the limit is enforced.
 
 UML_LIMIT_NUM_FIELDS   = 10
 
 # If set to YES, the inheritance and collaboration graphs will show the
 # relations between templates and their instances.
 
 TEMPLATE_RELATIONS     = YES
 
 # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
 # tags are set to YES then doxygen will generate a graph for each documented
 # file showing the direct and indirect include dependencies of the file with
 # other documented files.
 
 INCLUDE_GRAPH          = NO
 
 # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
 # HAVE_DOT tags are set to YES then doxygen will generate a graph for each
 # documented header file showing the documented files that directly or
 # indirectly include this file.
 
 INCLUDED_BY_GRAPH      = NO
 
 # If the CALL_GRAPH and HAVE_DOT options are set to YES then
 # doxygen will generate a call dependency graph for every global function
 # or class method. Note that enabling this option will significantly increase
 # the time of a run. So in most cases it will be better to enable call graphs
 # for selected functions only using the \callgraph command.
 
 CALL_GRAPH             = NO
 
 # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
 # doxygen will generate a caller dependency graph for every global function
 # or class method. Note that enabling this option will significantly increase
 # the time of a run. So in most cases it will be better to enable caller
 # graphs for selected functions only using the \callergraph command.
 
 CALLER_GRAPH           = NO
 
 # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
 # will generate a graphical hierarchy of all classes instead of a textual one.
 
 GRAPHICAL_HIERARCHY    = NO
 
 # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
 # then doxygen will show the dependencies a directory has on other directories
 # in a graphical way. The dependency relations are determined by the #include
 # relations between the files in the directories.
 
 DIRECTORY_GRAPH        = YES
 
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
 # generated by dot. Possible values are svg, png, jpg, or gif.
 # If left blank png will be used. If you choose svg you need to set
 # HTML_FILE_EXTENSION to xhtml in order to make the SVG files
 # visible in IE 9+ (other browsers do not have this requirement).
 
 DOT_IMAGE_FORMAT       = png
 
 # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
 # enable generation of interactive SVG images that allow zooming and panning.
 # Note that this requires a modern browser other than Internet Explorer.
 # Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
 # need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
 # visible. Older versions of IE do not have SVG support.
 
 INTERACTIVE_SVG        = NO
 
 # The tag DOT_PATH can be used to specify the path where the dot tool can be
 # found. If left blank, it is assumed the dot tool can be found in the path.
 
 DOT_PATH               = @DOXYGEN_DOT_PATH@
 
 # The DOTFILE_DIRS tag can be used to specify one or more directories that
 # contain dot files that are included in the documentation (see the
 # \dotfile command).
 
 DOTFILE_DIRS           =
 
 # The MSCFILE_DIRS tag can be used to specify one or more directories that
 # contain msc files that are included in the documentation (see the
 # \mscfile command).
 
 MSCFILE_DIRS           =
 
 # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
 # nodes that will be shown in the graph. If the number of nodes in a graph
 # becomes larger than this value, doxygen will truncate the graph, which is
 # visualized by representing a node as a red box. Note that doxygen if the
 # number of direct children of the root node in a graph is already larger than
 # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
 # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
 
 DOT_GRAPH_MAX_NODES    = 50
 
 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
 # graphs generated by dot. A depth value of 3 means that only nodes reachable
 # from the root by following a path via at most 3 edges will be shown. Nodes
 # that lay further from the root node will be omitted. Note that setting this
 # option to 1 or 2 may greatly reduce the computation time needed for large
 # code bases. Also note that the size of a graph can be further restricted by
 # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
 
 MAX_DOT_GRAPH_DEPTH    = 0
 
 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
 # background. This is disabled by default, because dot on Windows does not
 # seem to support this out of the box. Warning: Depending on the platform used,
 # enabling this option may lead to badly anti-aliased labels on the edges of
 # a graph (i.e. they become hard to read).
 
 DOT_TRANSPARENT        = NO
 
 # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
 # files in one run (i.e. multiple -o and -T options on the command line). This
 # makes dot run faster, but since only newer versions of dot (>1.8.10)
 # support this, this feature is disabled by default.
 
 DOT_MULTI_TARGETS      = NO
 
 # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
 # generate a legend page explaining the meaning of the various boxes and
 # arrows in the dot generated graphs.
 
 GENERATE_LEGEND        = YES
 
 # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
 # remove the intermediate dot files that are used to generate
 # the various graphs.
 
 DOT_CLEANUP            = YES
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
index 68766b321f..aeb95dcd04 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
@@ -1,690 +1,734 @@
 /*===================================================================
 
 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 "mitkPlanarFigureMapper2D.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkGL.h"
 #include "mitkVtkPropRenderer.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // offset which moves the planarfigures on top of the other content
 // the crosshair is rendered into the z = 1 layer. 
 static const float PLANAR_OFFSET = 0.5f;
 
 mitk::PlanarFigureMapper2D::PlanarFigureMapper2D()
 {
   this->InitializeDefaultPlanarFigureProperties();
 }
 
 
 mitk::PlanarFigureMapper2D::~PlanarFigureMapper2D()
 {
 }
 
 
 void mitk::PlanarFigureMapper2D::Paint( mitk::BaseRenderer *renderer )
 {
   if ( !this->IsVisible( renderer ) ) 
   {
     return;
   }
 
   // Get PlanarFigure from input
   mitk::PlanarFigure *planarFigure = const_cast< mitk::PlanarFigure * >(
     static_cast< const mitk::PlanarFigure * >( this->GetData() ) );
 
   // Check if PlanarFigure has already been placed; otherwise, do nothing
   if ( !planarFigure->IsPlaced() )
   {
     return;
   }
 
   // Get 2D geometry frame of PlanarFigure
   mitk::Geometry2D *planarFigureGeometry2D = 
     dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
   if ( planarFigureGeometry2D == NULL )
   {
     MITK_ERROR << "PlanarFigure does not have valid Geometry2D!";
     return;
   }
 
   // Get current world 2D geometry from renderer
   const mitk::Geometry2D *rendererGeometry2D = renderer->GetCurrentWorldGeometry2D();
 
   // If the PlanarFigure geometry is a plane geometry, check if current
   // world plane is parallel to and within the planar figure geometry bounds
   // (otherwise, display nothing)
   mitk::PlaneGeometry *planarFigurePlaneGeometry = 
     dynamic_cast< PlaneGeometry * >( planarFigureGeometry2D );
   const mitk::PlaneGeometry *rendererPlaneGeometry = 
     dynamic_cast< const PlaneGeometry * >( rendererGeometry2D );
 
   if ( (planarFigurePlaneGeometry != NULL) && (rendererPlaneGeometry != NULL) )
   {
     double planeThickness = planarFigurePlaneGeometry->GetExtentInMM( 2 );
     if ( !planarFigurePlaneGeometry->IsParallel( rendererPlaneGeometry )
       || !(planarFigurePlaneGeometry->DistanceFromPlane( 
       rendererPlaneGeometry ) < planeThickness / 3.0) )
     {
       // Planes are not parallel or renderer plane is not within PlanarFigure
       // geometry bounds --> exit
       return;
     }
   }
   else
   {
     // Plane is not valid (curved reformations are not possible yet)
     return;
   }
 
 
   // Get display geometry
   mitk::DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
   assert( displayGeometry != NULL );
 
 
   // Apply visual appearance properties from the PropertyList
   this->ApplyProperties( renderer );
 
   // Enable line antialiasing
   glEnable( GL_LINE_SMOOTH );
   glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
   glEnable(GL_DEPTH_TEST);
   
   // Get properties from node (if present)
   const mitk::DataNode* node=this->GetDataNode();
   this->InitializePlanarFigurePropertiesFromDataNode( node );
 
   PlanarFigureDisplayMode lineDisplayMode = PF_DEFAULT;
 
   if ( m_IsSelected )
   {
     lineDisplayMode = PF_SELECTED;
   }
   else if ( m_IsHovering )
   {
     lineDisplayMode = PF_HOVER;
   }
 
   mitk::Point2D firstPoint; firstPoint[0] = 0; firstPoint[1] = 1;
 
   if ( m_DrawOutline )
   {
     // Draw the outline for all polylines if requested
     this->DrawMainLines( planarFigure,
       m_OutlineColor[lineDisplayMode],
       m_OutlineOpacity[lineDisplayMode],
       m_DrawShadow,
       m_OutlineWidth,
       m_ShadowWidthFactor,
       firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
     // Draw the outline for all helper objects if requested
     this->DrawHelperLines( planarFigure,
       m_OutlineColor[lineDisplayMode],
       m_OutlineOpacity[lineDisplayMode],
       m_DrawShadow,
       m_OutlineWidth,
       m_ShadowWidthFactor,
       firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 
 
   // Draw the main line for all polylines
   this->DrawMainLines( planarFigure,
     m_LineColor[lineDisplayMode],
     m_LineOpacity[lineDisplayMode],
     m_DrawShadow,
     m_LineWidth,
     m_ShadowWidthFactor,
     firstPoint,
     planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
   double annotationOffset = 0.0;
 
+  //Get Global Opacity
+  float globalOpacity = 1.0;
+  node->GetFloatProperty("opacity", globalOpacity);
+
   // draw name near the first point (if present)
   std::string name = node->GetName();
   if ( m_DrawName && !name.empty() )
   {
     mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
     if ( openGLrenderer )
     {
       openGLrenderer->WriteSimpleText( name,
         firstPoint[0] + 6.0, firstPoint[1] + 4.0,
         0,
         0,
-        0); //this is a shadow 
+        0,
+        globalOpacity ); //this is a shadow
       openGLrenderer->WriteSimpleText( name,
         firstPoint[0] + 5.0, firstPoint[1] + 5.0,
         m_LineColor[lineDisplayMode][0],
         m_LineColor[lineDisplayMode][1],
-        m_LineColor[lineDisplayMode][2] );
+        m_LineColor[lineDisplayMode][2],
+        globalOpacity );
     
       // If drawing is successful, add approximate height to annotation offset
       annotationOffset -= 15.0;
     }
   }
 
   // draw feature quantities (if requested) new the first point
   if ( m_DrawQuantities )
   {
     std::stringstream quantityString;
     quantityString.setf( ios::fixed, ios::floatfield );
     quantityString.precision( 1 );
 
     bool firstActiveFeature = true;
     for ( unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i )
     {     
       if( planarFigure->IsFeatureActive(i) && planarFigure->IsFeatureVisible( i ) )
       {
         if ( ! firstActiveFeature ) 
         {
           quantityString << " x ";
         }
         quantityString << planarFigure->GetQuantity( i ) << " ";
         quantityString << planarFigure->GetFeatureUnit( i );
         firstActiveFeature = false;
       }
     }
 
     mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
     if ( openGLrenderer )
     {
       openGLrenderer->WriteSimpleText( quantityString.str().c_str(), 
         firstPoint[0] + 6.0, firstPoint[1] + 4.0 + annotationOffset,
         0,
         0,
-        0); //this is a shadow 
+        0,
+        globalOpacity ); //this is a shadow
 
       openGLrenderer->WriteSimpleText( quantityString.str().c_str(),
         firstPoint[0] + 5.0, firstPoint[1] + 5.0 + annotationOffset,
         m_LineColor[lineDisplayMode][0],
         m_LineColor[lineDisplayMode][1],
-        m_LineColor[lineDisplayMode][2] );
+        m_LineColor[lineDisplayMode][2],
+        globalOpacity );
 
       // If drawing is successful, add approximate height to annotation offset
       annotationOffset -= 15.0;
     }
   }
 
 
   // Draw helper objects
   this->DrawHelperLines( planarFigure,
     m_HelperlineColor[lineDisplayMode],
     m_HelperlineOpacity[lineDisplayMode],
     m_DrawShadow,
     m_LineWidth,
     m_ShadowWidthFactor,
     firstPoint,
     planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
 
   if ( m_DrawControlPoints )
   {
     // Draw markers at control points (selected control point will be colored)
     for ( unsigned int i = 0; i < planarFigure->GetNumberOfControlPoints(); ++i )
     {
 
       bool isEditable = true;
       m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
       PlanarFigureDisplayMode pointDisplayMode = PF_DEFAULT;
 
       // Only if planar figure is marked as editable: display markers (control points) in a
       // different style if mouse is over them or they are selected
       if ( isEditable )
       {
         if ( i == (unsigned int) planarFigure->GetSelectedControlPoint() )
         {
           pointDisplayMode = PF_SELECTED;
         }
         else if ( m_IsHovering )
         {
           pointDisplayMode = PF_HOVER;
         }
       }
 
       this->DrawMarker( planarFigure->GetControlPoint( i ),
         m_MarkerlineColor[pointDisplayMode],
         m_MarkerlineOpacity[pointDisplayMode],
         m_MarkerColor[pointDisplayMode],
         m_MarkerOpacity[pointDisplayMode],
         m_LineWidth,
         m_ControlPointShape,
         planarFigureGeometry2D, 
         rendererGeometry2D, 
         displayGeometry );
     }
 
     if ( planarFigure->IsPreviewControlPointVisible() )
     {
       this->DrawMarker( planarFigure->GetPreviewControlPoint(),
         m_MarkerlineColor[PF_HOVER],
         m_MarkerlineOpacity[PF_HOVER],
         m_MarkerColor[PF_HOVER],
         m_MarkerOpacity[PF_HOVER],
         m_LineWidth,
         m_ControlPointShape,
         planarFigureGeometry2D, 
         rendererGeometry2D, 
         displayGeometry 
         );
     }
   }
 
   glLineWidth( 1.0f );
 }
 
 
 void mitk::PlanarFigureMapper2D::PaintPolyLine(
   mitk::PlanarFigure::PolyLineType vertices,  
   bool closed,
   float* color, 
   float opacity, 
   float lineWidth, 
   Point2D& firstPoint, 
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   glColor4f( color[0], color[1], color[2], opacity );
   glLineWidth(lineWidth);
 
   if ( closed )
   {
     glBegin( GL_LINE_LOOP );
   }
   else 
   {
     glBegin( GL_LINE_STRIP );
   }
 
   for ( PlanarFigure::PolyLineType::iterator iter = vertices.begin(); iter!=vertices.end(); iter++ )
   {
     // Draw this 2D point as OpenGL vertex
     mitk::Point2D displayPoint;
     this->TransformObjectToDisplay( iter->Point, displayPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
     if(iter == vertices.begin())
       firstPoint = displayPoint;
 
     glVertex3f( displayPoint[0], displayPoint[1], PLANAR_OFFSET );
   }
 
   glEnd();
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMainLines( 
   mitk::PlanarFigure* figure, 
   float* color, 
   float opacity, 
   bool drawShadow,
   float lineWidth, 
   float shadowWidthFactor,
   Point2D& firstPoint,
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   for ( unsigned short loop = 0; loop < figure->GetPolyLinesSize(); ++loop )
   {
     PlanarFigure::PolyLineType polyline = figure->GetPolyLine(loop);
 
     if ( drawShadow )
     {
       float* shadow = new float[3];
       shadow[0] = 0;
       shadow[1] = 0;
       shadow[2] = 0;
 
+      //set shadow opacity
+      float shadowOpacity = 0.0f;
+      if( opacity > 0.2f )
+        shadowOpacity = opacity - 0.2f;
+
       this->PaintPolyLine( polyline, 
         figure->IsClosed(),    
-        shadow, 0.8, lineWidth*shadowWidthFactor, firstPoint,
+        shadow, shadowOpacity, lineWidth*shadowWidthFactor, firstPoint,
         planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
       delete shadow;
     }
 
     this->PaintPolyLine( polyline, 
       figure->IsClosed(),    
       color, opacity, lineWidth, firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 }
 
 void mitk::PlanarFigureMapper2D::DrawHelperLines(
   mitk::PlanarFigure* figure,
   float* color, 
   float opacity, 
   bool drawShadow,
   float lineWidth,
   float shadowWidthFactor,
   Point2D& firstPoint,
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   // Draw helper objects
   for ( unsigned int loop = 0; loop < figure->GetHelperPolyLinesSize(); ++loop )
   {
     const mitk::PlanarFigure::PolyLineType helperPolyLine = figure->GetHelperPolyLine(loop,
       displayGeometry->GetScaleFactorMMPerDisplayUnit(),
       displayGeometry->GetDisplayHeight() );
 
     // Check if the current helper objects is to be painted
     if ( !figure->IsHelperToBePainted( loop ) )
     {
       continue;
     }
 
     // check if shadow shall be painted around the figure
     if ( drawShadow )
     {
       float* shadow = new float[3];
       shadow[0] = 0;
       shadow[1] = 0;
       shadow[2] = 0;
 
+      //set shadow opacity
+      float shadowOpacity = 0.0f;
+      if( opacity > 0.2f )
+        shadowOpacity = opacity - 0.2f;
+
       // paint shadow by painting the figure twice
       // one in black with a slightly broader line-width ...
       this->PaintPolyLine( helperPolyLine, false,
-        shadow, 0.8, lineWidth*shadowWidthFactor, firstPoint,
+        shadow, shadowOpacity, lineWidth*shadowWidthFactor, firstPoint,
         planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
       delete shadow;
     }
 
     // ... and once normally above the shadow.
     this->PaintPolyLine( helperPolyLine, false,
       color, opacity, lineWidth, firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 }
 
 
 
 void mitk::PlanarFigureMapper2D::TransformObjectToDisplay(
   const mitk::Point2D &point2D,
   mitk::Point2D &displayPoint,
   const mitk::Geometry2D *objectGeometry,
   const mitk::Geometry2D *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry )
 {
   mitk::Point3D point3D;
 
   // Map circle point from local 2D geometry into 3D world space
   objectGeometry->Map( point2D, point3D );
 
   // Project 3D world point onto display geometry
   rendererGeometry->Map( point3D, displayPoint );
   displayGeometry->WorldToDisplay( displayPoint, displayPoint );
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMarker(
   const mitk::Point2D &point,
   float* lineColor,
   float lineOpacity,
   float* markerColor,
   float markerOpacity,
   float lineWidth,
   PlanarFigureControlPointStyleProperty::Shape shape,
   const mitk::Geometry2D *objectGeometry,
   const mitk::Geometry2D *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry )
 {
   mitk::Point2D displayPoint;
 
   if ( markerOpacity == 0 && lineOpacity == 0 )
     return;
 
   this->TransformObjectToDisplay(
     point, displayPoint,
     objectGeometry, rendererGeometry, displayGeometry );
 
   glColor4f( markerColor[0], markerColor[1], markerColor[2], markerOpacity );
   glLineWidth( lineWidth );
 
   switch ( shape )
   {
   case PlanarFigureControlPointStyleProperty::Square:
   default:
     // Paint filled square
 
     // Disable line antialiasing (does not look nice for squares)
     glDisable( GL_LINE_SMOOTH );
 
     glRectf(
       displayPoint[0] - 4, displayPoint[1] - 4, 
       displayPoint[0] + 4, displayPoint[1] + 4 );
 
     // Paint outline
     glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
     glBegin( GL_LINE_LOOP );
     glVertex3f( displayPoint[0] - 4, displayPoint[1] - 4, PLANAR_OFFSET );
     glVertex3f( displayPoint[0] - 4, displayPoint[1] + 4, PLANAR_OFFSET );
     glVertex3f( displayPoint[0] + 4, displayPoint[1] + 4, PLANAR_OFFSET );
     glVertex3f( displayPoint[0] + 4, displayPoint[1] - 4, PLANAR_OFFSET );
     glEnd();
     break;
 
   case PlanarFigureControlPointStyleProperty::Circle:
     // Paint filled circle
     glBegin( GL_POLYGON );
     float radius = 4.0;
     for ( int angle = 0; angle < 8; ++angle )
     {
       float angleRad = angle * (float) 3.14159 / 4.0;
       float x = displayPoint[0] + radius * (float)cos( angleRad );
       float y = displayPoint[1] + radius * (float)sin( angleRad );
       glVertex3f(x, y, PLANAR_OFFSET);
     }
     glEnd();
 
     // Paint outline
     glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
     glBegin( GL_LINE_LOOP );
     for ( int angle = 0; angle < 8; ++angle )
     {
       float angleRad = angle * (float) 3.14159 / 4.0;
       float x = displayPoint[0] + radius * (float)cos( angleRad );
       float y = displayPoint[1] + radius * (float)sin( angleRad );
       glVertex3f(x, y, PLANAR_OFFSET);
     }
     glEnd();
     break;
 
   } // end switch
 }
 
 
 void mitk::PlanarFigureMapper2D::InitializeDefaultPlanarFigureProperties()
 {
   m_IsSelected = false;
   m_IsHovering = false;
   m_DrawOutline = false;
   m_DrawQuantities = false;
   m_DrawShadow = false;
   m_DrawControlPoints = false;
   m_DrawName = true;
 
   m_ShadowWidthFactor = 1.2;
   m_LineWidth = 1.0;
   m_OutlineWidth = 4.0;
   m_HelperlineWidth = 2.0;
 
   m_ControlPointShape = PlanarFigureControlPointStyleProperty::Square;
 
   this->SetColorProperty( m_LineColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_LineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_DEFAULT, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_DEFAULT, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_DEFAULT, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_DEFAULT, 0.0 );
 
   this->SetColorProperty( m_LineColor, PF_HOVER, 1.0, 0.7, 0.0 );
   this->SetFloatProperty( m_LineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_HOVER, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_HOVER, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_HOVER, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_HOVER, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_HOVER, 1.0, 0.6, 0.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_HOVER, 0.2 );
 
   this->SetColorProperty( m_LineColor, PF_SELECTED, 1.0, 0.0, 0.0 );
   this->SetFloatProperty( m_LineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_SELECTED, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_SELECTED, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_SELECTED, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_SELECTED, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_SELECTED, 1.0, 0.6, 0.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_SELECTED, 1.0 );
 }
 
 
 void mitk::PlanarFigureMapper2D::InitializePlanarFigurePropertiesFromDataNode( const mitk::DataNode* node )
 {
   if ( node == NULL )
   {
     return;
   }
 
+  //Get Global Opacity
+  float globalOpacity = 1.0;
+  node->GetFloatProperty("opacity", globalOpacity);
+
   node->GetBoolProperty( "selected", m_IsSelected );
   node->GetBoolProperty( "planarfigure.ishovering", m_IsHovering );
   node->GetBoolProperty( "planarfigure.drawoutline", m_DrawOutline );
-  node->GetBoolProperty( "planarfigure.drawquantities", m_DrawQuantities );
   node->GetBoolProperty( "planarfigure.drawshadow", m_DrawShadow );
+  node->GetBoolProperty( "planarfigure.drawquantities", m_DrawQuantities );
   node->GetBoolProperty( "planarfigure.drawcontrolpoints", m_DrawControlPoints );
   node->GetBoolProperty( "planarfigure.drawname", m_DrawName );
 
   node->GetFloatProperty( "planarfigure.line.width", m_LineWidth );
   node->GetFloatProperty( "planarfigure.shadow.widthmodifier", m_ShadowWidthFactor );
   node->GetFloatProperty( "planarfigure.outline.width", m_OutlineWidth );
   node->GetFloatProperty( "planarfigure.helperline.width", m_HelperlineWidth );
 
   PlanarFigureControlPointStyleProperty::Pointer styleProperty = 
     dynamic_cast< PlanarFigureControlPointStyleProperty* >( node->GetProperty( "planarfigure.controlpointshape" ) );
   if ( styleProperty.IsNotNull() )
   {
     m_ControlPointShape = styleProperty->GetShape();
   }
 
-  node->GetColor( m_LineColor[PF_DEFAULT], NULL, "planarfigure.default.line.color" );
+  //Set default color and opacity
+  //If property "planarfigure.default.*.color" exists, then use that color. Otherwise global "color" property is used.
+  if( !node->GetColor( m_LineColor[PF_DEFAULT], NULL, "planarfigure.default.line.color"))
+  {
+    node->GetColor( m_LineColor[PF_DEFAULT], NULL, "color" );
+  }
   node->GetFloatProperty( "planarfigure.default.line.opacity", m_LineOpacity[PF_DEFAULT] );
-  node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "planarfigure.default.outline.color" );
+
+  if( !node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "planarfigure.default.outline.color"))
+  {
+    node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "color" );
+  }
   node->GetFloatProperty( "planarfigure.default.outline.opacity", m_OutlineOpacity[PF_DEFAULT] );
-  node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "planarfigure.default.helperline.color" );
+
+  if( !node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "planarfigure.default.helperline.color"))
+  {
+    node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "color" );
+  }
   node->GetFloatProperty( "planarfigure.default.helperline.opacity", m_HelperlineOpacity[PF_DEFAULT] );
+
   node->GetColor( m_MarkerlineColor[PF_DEFAULT], NULL, "planarfigure.default.markerline.color" );
   node->GetFloatProperty( "planarfigure.default.markerline.opacity", m_MarkerlineOpacity[PF_DEFAULT] );
   node->GetColor( m_MarkerColor[PF_DEFAULT], NULL, "planarfigure.default.marker.color" );
   node->GetFloatProperty( "planarfigure.default.marker.opacity", m_MarkerOpacity[PF_DEFAULT] );
 
+  //Set hover color and opacity
   node->GetColor( m_LineColor[PF_HOVER], NULL, "planarfigure.hover.line.color" );
   node->GetFloatProperty( "planarfigure.hover.line.opacity", m_LineOpacity[PF_HOVER] );
   node->GetColor( m_OutlineColor[PF_HOVER], NULL, "planarfigure.hover.outline.color" );
   node->GetFloatProperty( "planarfigure.hover.outline.opacity", m_OutlineOpacity[PF_HOVER] );
   node->GetColor( m_HelperlineColor[PF_HOVER], NULL, "planarfigure.hover.helperline.color" );
   node->GetFloatProperty( "planarfigure.hover.helperline.opacity", m_HelperlineOpacity[PF_HOVER] );
   node->GetColor( m_MarkerlineColor[PF_HOVER], NULL, "planarfigure.hover.markerline.color" );
   node->GetFloatProperty( "planarfigure.hover.markerline.opacity", m_MarkerlineOpacity[PF_HOVER] );
   node->GetColor( m_MarkerColor[PF_HOVER], NULL, "planarfigure.hover.marker.color" );
   node->GetFloatProperty( "planarfigure.hover.marker.opacity", m_MarkerOpacity[PF_HOVER] );
 
+  //Set selected color and opacity
   node->GetColor( m_LineColor[PF_SELECTED], NULL, "planarfigure.selected.line.color" );
   node->GetFloatProperty( "planarfigure.selected.line.opacity", m_LineOpacity[PF_SELECTED] );
   node->GetColor( m_OutlineColor[PF_SELECTED], NULL, "planarfigure.selected.outline.color" );
   node->GetFloatProperty( "planarfigure.selected.outline.opacity", m_OutlineOpacity[PF_SELECTED] );
   node->GetColor( m_HelperlineColor[PF_SELECTED], NULL, "planarfigure.selected.helperline.color" );
   node->GetFloatProperty( "planarfigure.selected.helperline.opacity", m_HelperlineOpacity[PF_SELECTED] );
   node->GetColor( m_MarkerlineColor[PF_SELECTED], NULL, "planarfigure.selected.markerline.color" );
   node->GetFloatProperty( "planarfigure.selected.markerline.opacity", m_MarkerlineOpacity[PF_SELECTED] );
   node->GetColor( m_MarkerColor[PF_SELECTED], NULL, "planarfigure.selected.marker.color" );
   node->GetFloatProperty( "planarfigure.selected.marker.opacity", m_MarkerOpacity[PF_SELECTED] );
 
+  //adapt opacity values to global "opacity" property
+  for( unsigned int i = 0; i < PF_COUNT; ++i )
+  {
+    m_LineOpacity[i] *= globalOpacity;
+    m_OutlineOpacity[i] *= globalOpacity;
+    m_HelperlineOpacity[i] *= globalOpacity;
+    m_MarkerlineOpacity[i] *= globalOpacity;
+    m_MarkerOpacity[i] *= globalOpacity;
+  }
 }
 
 
 void mitk::PlanarFigureMapper2D::SetDefaultProperties( mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite )
 {
   node->AddProperty( "visible", mitk::BoolProperty::New(true), renderer, overwrite );
 
   //node->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   //node->SetProperty("planarfigure.isextendable",mitk::BoolProperty::New(true));
   //node->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(true) );
   //node->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawcontrolpoints", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawname", mitk::BoolProperty::New(true) );
 
   node->AddProperty("planarfigure.line.width", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.helperline.width", mitk::FloatProperty::New(2.0) );
 
-  node->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(1.0) );
-  node->AddProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(1.0) );
-  node->AddProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(1.0) );
 
   node->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(1.0) );
 
   node->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(1.0));
 }
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
index 3d91db673c..9cfc0274ec 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
@@ -1,242 +1,244 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef MITK_PLANAR_FIGURE_MAPPER_2D_H_
 #define MITK_PLANAR_FIGURE_MAPPER_2D_H_
 
 #include "mitkCommon.h"
 #include "PlanarFigureExports.h"
 #include "mitkGLMapper2D.h"
 #include "mitkPlanarFigure.h"
 #include "mitkPlanarFigureControlPointStyleProperty.h"
 
 namespace mitk {
 
 class BaseRenderer;
 class Contour;
 
 
 /**
 * \brief OpenGL-based mapper to render display sub-class instances of mitk::PlanarFigure
 * 
 * The appearance of planar figures can be configured through  properties. If no properties are specified,
 * default values will be used. There are four elements a planar figure consists of:
 * 
 * <ol>
 * <li>"line": the main line segments of the planar figure (note: text is drawn in the same style)
 * <li>"helperline": additional line segments of planar figures, such as arrow tips, arches of angles, etc.
 * <li>"outline": background which is drawn behind the lines and helperlines of the planar figure (optional)
 * <li>"marker": the markers (control points) of a planar figure
 * <li>"markerline": the lines by which markers (control points) are surrounded
 * </ol>
 * 
 * In the following, all appearance-related planar figure properties are listed:
 * 
 * <ol>
 * <li>General properties for the planar figure
 *   <ul>
 *     <li>"planarfigure.drawoutline": if true, the "outline" lines is drawn
 *     <li>"planarfigure.drawquantities": if true, the quantities (text) associated with the planar figure is drawn
 *     <li>"planarfigure.drawname": if true, the name specified by the dataNode is drawn
 *     <li>"planarfigure.drawshadow": if true, a black shadow is drawn around the planar figure
 *     <li>"planarfigure.controlpointshape": style of the control points (enum)
 *   </ul>
 * <li>Line widths of planar figure elements
 *   <ul>
 *     <li>"planarfigure.line.width": width of "line" segments (float value, in mm)
 *     <li>"planarfigure.shadow.widthmodifier": the width of the shadow is defined by width of the "line" * this modifier
 *     <li>"planarfigure.outline.width": width of "outline" segments (float value, in mm)
 *     <li>"planarfigure.helperline.width": width of "helperline" segments (float value, in mm)
 *   </ul>
 * <li>Color/opacity of planar figure elements in normal mode (unselected)
 *   <ul>
 *     <li>"planarfigure.default.line.color"
 *     <li>"planarfigure.default.line.opacity"
 *     <li>"planarfigure.default.outline.color"
 *     <li>"planarfigure.default.outline.opacity"
 *     <li>"planarfigure.default.helperline.color"
 *     <li>"planarfigure.default.helperline.opacity"
 *     <li>"planarfigure.default.markerline.color"
 *     <li>"planarfigure.default.markerline.opacity"
 *     <li>"planarfigure.default.marker.color"
 *     <li>"planarfigure.default.marker.opacity"
 *   </ul>
 * <li>Color/opacity of planar figure elements in hover mode (mouse-over)
 *   <ul>
 *     <li>"planarfigure.hover.line.color"
 *     <li>"planarfigure.hover.line.opacity"
 *     <li>"planarfigure.hover.outline.color"
 *     <li>"planarfigure.hover.outline.opacity"
 *     <li>"planarfigure.hover.helperline.color"
 *     <li>"planarfigure.hover.helperline.opacity"
 *     <li>"planarfigure.hover.markerline.color"
 *     <li>"planarfigure.hover.markerline.opacity"
 *     <li>"planarfigure.hover.marker.color"
 *     <li>"planarfigure.hover.marker.opacity"
 *   </ul>
 * <li>Color/opacity of planar figure elements in selected mode
 *   <ul>
 *     <li>"planarfigure.selected.line.color"
 *     <li>"planarfigure.selected.line.opacity"
 *     <li>"planarfigure.selected.outline.color"
 *     <li>"planarfigure.selected.outline.opacity"
 *     <li>"planarfigure.selected.helperline.color"
 *     <li>"planarfigure.selected.helperline.opacity"
 *     <li>"planarfigure.selected.markerline.color;"
 *     <li>"planarfigure.selected.markerline.opacity"
 *     <li>"planarfigure.selected.marker.color"
 *     <li>"planarfigure.selected.marker.opacity"
 *   </ul>
 * </ol>
 *
 * \ingroup Mapper
 */
 
 class PlanarFigure_EXPORT PlanarFigureMapper2D : public GLMapper2D
 {
 public:
     
   mitkClassMacro(PlanarFigureMapper2D, Mapper2D);
 
   itkNewMacro(Self);
 
   /**
   * reimplemented from Baseclass
   */
   virtual void Paint(BaseRenderer * renderer);
 
   static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
 
 protected:
   
   enum PlanarFigureDisplayMode
   {
     PF_DEFAULT = 0,
-    PF_HOVER,
-    PF_SELECTED
+    PF_HOVER = 1,
+    PF_SELECTED = 2,
+
+    PF_COUNT = 3 //helper variable
   };
 
   PlanarFigureMapper2D();
 
   virtual ~PlanarFigureMapper2D();
 
   void TransformObjectToDisplay(
     const mitk::Point2D &point2D,
     mitk::Point2D &displayPoint,
     const mitk::Geometry2D *objectGeometry,
     const mitk::Geometry2D *rendererGeometry,
     const mitk::DisplayGeometry *displayGeometry );
 
   void DrawMarker(
     const mitk::Point2D &point,
     float* lineColor,
     float lineOpacity,
     float* markerColor,
     float markerOpacity,
     float lineWidth,
     PlanarFigureControlPointStyleProperty::Shape shape,
     const mitk::Geometry2D *objectGeometry,
     const mitk::Geometry2D *rendererGeometry,
     const mitk::DisplayGeometry *displayGeometry );
 
   void PaintPolyLine( mitk::PlanarFigure::PolyLineType vertices,
     bool closed,
     float* color, 
     float opacity, 
     float lineWidth, 
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry);
 
   void DrawMainLines( mitk::PlanarFigure* figure, 
     float* color, 
     float opacity, 
     bool drawShadow,
     float lineWidth, 
     float shadowWidthFactor,
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry) ;
 
   void DrawHelperLines( mitk::PlanarFigure* figure,
     float* color, 
     float opacity, 
     bool drawShadow,
     float lineWidth, 
     float shadowWidthFactor,
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry) ;
 
   void InitializeDefaultPlanarFigureProperties();
 
   void InitializePlanarFigurePropertiesFromDataNode( const mitk::DataNode* node );
 
   void SetColorProperty( float property[3][3], PlanarFigureDisplayMode mode, float red, float green, float blue )
   {
     property[mode][0] = red;
     property[mode][1] = green;
     property[mode][2] = blue;
   }
 
   void SetFloatProperty( float* property, PlanarFigureDisplayMode mode, float value )
   {
     property[mode] = value;
   }
 
 
 
 private:
   bool m_IsSelected;
   bool m_IsHovering;
   bool m_DrawOutline;
   bool m_DrawQuantities;
   bool m_DrawShadow;
   bool m_DrawControlPoints;
   bool m_DrawName;
 
   // the width of the shadow is defined as 'm_LineWidth * m_ShadowWidthFactor'
   float m_LineWidth;
   float m_ShadowWidthFactor;
   float m_OutlineWidth;
   float m_HelperlineWidth;
   float m_PointWidth;
 
   PlanarFigureControlPointStyleProperty::Shape m_ControlPointShape;
 
   float m_LineColor[3][3];
   float m_LineOpacity[3];
   float m_OutlineColor[3][3];
   float m_OutlineOpacity[3];
   float m_HelperlineColor[3][3];
   float m_HelperlineOpacity[3];
   float m_MarkerlineColor[3][3];
   float m_MarkerlineOpacity[3];
   float m_MarkerColor[3][3];
   float m_MarkerOpacity[3];
 
 };
 
 } // namespace mitk
 
 
 
 #endif /* MITK_PLANAR_FIGURE_MAPPER_2D_H_ */
diff --git a/Modules/Qmitk/QmitkStdMultiWidget.cpp b/Modules/Qmitk/QmitkStdMultiWidget.cpp
index 92b48792e6..447d43a513 100644
--- a/Modules/Qmitk/QmitkStdMultiWidget.cpp
+++ b/Modules/Qmitk/QmitkStdMultiWidget.cpp
@@ -1,2216 +1,2218 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #define SMW_INFO MITK_INFO("widget.stdmulti")
 
 #include "QmitkStdMultiWidget.h"
 
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QGridLayout>
 #include <qsplitter.h>
 #include <QMotifStyle>
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 
 #include "mitkProperties.h"
 #include "mitkGeometry2DDataMapper2D.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkDisplayInteractor.h"
 #include "mitkPointSet.h"
 #include "mitkPositionEvent.h"
 #include "mitkStateEvent.h"
 #include "mitkLine.h"
 #include "mitkInteractionConst.h"
 #include "mitkDataStorage.h"
 
 #include "mitkNodePredicateBase.h"
 #include "mitkNodePredicateDataType.h"
 
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkStatusBar.h"
 #include "mitkImage.h"
 
 #include "mitkVtkLayerController.h"
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget* parent, Qt::WindowFlags f, mitk::RenderingManager* renderingManager)
 : QWidget(parent, f), 
 mitkWidget1(NULL),
 mitkWidget2(NULL),
 mitkWidget3(NULL),
 mitkWidget4(NULL),
 levelWindowWidget(NULL),
 QmitkStdMultiWidgetLayout(NULL),
 m_Layout(LAYOUT_DEFAULT),
 m_PlaneMode(PLANE_MODE_SLICING),
 m_RenderingManager(renderingManager),
 m_GradientBackgroundFlag(true),
 m_TimeNavigationController(NULL),
 m_MainSplit(NULL),
 m_LayoutSplit(NULL),
 m_SubSplit1(NULL),
 m_SubSplit2(NULL),
 mitkWidget1Container(NULL),
 mitkWidget2Container(NULL),
 mitkWidget3Container(NULL),
 mitkWidget4Container(NULL),
 m_PendingCrosshairPositionEvent(false),
 m_CrosshairNavigationEnabled(false)
 {
   /******************************************************
    * Use the global RenderingManager if none was specified
    * ****************************************************/
   if (m_RenderingManager == NULL)
   {
     m_RenderingManager = mitk::RenderingManager::GetInstance();
   }
   m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
 
   /*******************************/
   //Create Widget manually
   /*******************************/
 
   //create Layouts
   QmitkStdMultiWidgetLayout = new QHBoxLayout( this ); 
   QmitkStdMultiWidgetLayout->setContentsMargins(0,0,0,0);
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
 //  QmitkNavigationToolBar* toolBar = new QmitkNavigationToolBar();
 //  QmitkStdMultiWidgetLayout->addWidget( toolBar );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //creae Widget Container
   mitkWidget1Container = new QWidget(m_SubSplit1);
   mitkWidget2Container = new QWidget(m_SubSplit1);
   mitkWidget3Container = new QWidget(m_SubSplit2);
   mitkWidget4Container = new QWidget(m_SubSplit2);
 
   mitkWidget1Container->setContentsMargins(0,0,0,0);
   mitkWidget2Container->setContentsMargins(0,0,0,0);
   mitkWidget3Container->setContentsMargins(0,0,0,0);
   mitkWidget4Container->setContentsMargins(0,0,0,0);
 
   //create Widget Layout
   QHBoxLayout *mitkWidgetLayout1 = new QHBoxLayout(mitkWidget1Container);
   QHBoxLayout *mitkWidgetLayout2 = new QHBoxLayout(mitkWidget2Container);
   QHBoxLayout *mitkWidgetLayout3 = new QHBoxLayout(mitkWidget3Container);
   QHBoxLayout *mitkWidgetLayout4 = new QHBoxLayout(mitkWidget4Container);
 
   mitkWidgetLayout1->setMargin(0);
   mitkWidgetLayout2->setMargin(0);
   mitkWidgetLayout3->setMargin(0);
   mitkWidgetLayout4->setMargin(0);
 
   //set Layout to Widget Container  
   mitkWidget1Container->setLayout(mitkWidgetLayout1); 
   mitkWidget2Container->setLayout(mitkWidgetLayout2); 
   mitkWidget3Container->setLayout(mitkWidgetLayout3); 
   mitkWidget4Container->setLayout(mitkWidgetLayout4); 
 
   //set SizePolicy
   mitkWidget1Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget2Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget3Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget4Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
 
 
   //insert Widget Container into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //  m_RenderingManager->SetGlobalInteraction( mitk::GlobalInteraction::GetInstance() );
 
   //Create RenderWindows 1
   mitkWidget1 = new QmitkRenderWindow(mitkWidget1Container, "stdmulti.widget1", NULL, m_RenderingManager);
   mitkWidget1->setMaximumSize(2000,2000);
   mitkWidget1->SetLayoutIndex( AXIAL );
   mitkWidgetLayout1->addWidget(mitkWidget1); 
 
   //Create RenderWindows 2
   mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, "stdmulti.widget2", NULL, m_RenderingManager);
   mitkWidget2->setMaximumSize(2000,2000);
   mitkWidget2->setEnabled( TRUE );
   mitkWidget2->SetLayoutIndex( SAGITTAL );
   mitkWidgetLayout2->addWidget(mitkWidget2); 
 
   //Create RenderWindows 3
   mitkWidget3 = new QmitkRenderWindow(mitkWidget3Container, "stdmulti.widget3", NULL, m_RenderingManager);
   mitkWidget3->setMaximumSize(2000,2000);
   mitkWidget3->SetLayoutIndex( CORONAL );
   mitkWidgetLayout3->addWidget(mitkWidget3); 
 
   //Create RenderWindows 4
   mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, "stdmulti.widget4", NULL, m_RenderingManager);
   mitkWidget4->setMaximumSize(2000,2000);
   mitkWidget4->SetLayoutIndex( THREE_D );
   mitkWidgetLayout4->addWidget(mitkWidget4); 
 
   //create SignalSlot Connection
   connect( mitkWidget1, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget1, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget1, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget1, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget2, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget2, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget2, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget2, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget3, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget3, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget3, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget3, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget4, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget4, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget4, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget4, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   //Create Level Window Widget
   levelWindowWidget = new QmitkLevelWindowWidget( m_MainSplit ); //this
   levelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
   QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
   sizePolicy.setHorizontalStretch(0);
   sizePolicy.setVerticalStretch(0);
   sizePolicy.setHeightForWidth(levelWindowWidget->sizePolicy().hasHeightForWidth());
   levelWindowWidget->setSizePolicy(sizePolicy);
   levelWindowWidget->setMaximumSize(QSize(50, 2000));
   
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //resize Image.
   this->resize( QSize(364, 477).expandedTo(minimumSizeHint()) );
 
   //Initialize the widgets.
   this->InitializeWidget();
 
   //Activate Widget Menu
   this->ActivateMenuWidget( true );
 }
 
 void QmitkStdMultiWidget::InitializeWidget()
 {
   m_PositionTracker = NULL;
 
   // transfer colors in WorldGeometry-Nodes of the associated Renderer
   QColor qcolor;
   //float color[3] = {1.0f,1.0f,1.0f};
   mitk::DataNode::Pointer planeNode;
   mitk::IntProperty::Pointer  layer;
 
   // of widget 1
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(1.0,0.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 2
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(0.0,1.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 3
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(0.0,0.0,1.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 4
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(1.0,1.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   // Set plane mode (slicing/rotation behavior) to slicing (default)
   m_PlaneMode = PLANE_MODE_SLICING;
 
   // Set default view directions for SNCs
   mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Axial );
   mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Sagittal );
   mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Frontal );
   mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Original );
 
   /*************************************************/
   //Write Layout Names into the viewers -- hardCoded
 
   //Info for later: 
   //int view = this->GetRenderWindow1()->GetSliceNavigationController()->GetDefaultViewDirection();
   //QString layoutName;
   //if( view == mitk::SliceNavigationController::Axial )
   //  layoutName = "Axial";
   //else if( view == mitk::SliceNavigationController::Sagittal )
   //  layoutName = "Sagittal";
   //else if( view == mitk::SliceNavigationController::Frontal )
   //  layoutName = "Coronal";
   //else if( view == mitk::SliceNavigationController::Original )
   //  layoutName = "Original";
   //if( view >= 0 && view < 4 )
   //  //write LayoutName --> Viewer 3D shoudn't write the layoutName.
 
   //Render Window 1 == axial
   m_CornerAnnotaions[0].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[0].cornerText->SetText(0, "Axial");
   m_CornerAnnotaions[0].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[0].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[0].textProp->SetColor( 1.0, 0.0, 0.0 );
   m_CornerAnnotaions[0].cornerText->SetTextProperty( m_CornerAnnotaions[0].textProp );
   m_CornerAnnotaions[0].ren = vtkRenderer::New();
   m_CornerAnnotaions[0].ren->AddActor(m_CornerAnnotaions[0].cornerText);
   m_CornerAnnotaions[0].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[0].ren,true);
   
   //Render Window 2 == sagittal
   m_CornerAnnotaions[1].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[1].cornerText->SetText(0, "Sagittal");
   m_CornerAnnotaions[1].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[1].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[1].textProp->SetColor( 0.0, 1.0, 0.0 );
   m_CornerAnnotaions[1].cornerText->SetTextProperty( m_CornerAnnotaions[1].textProp );
   m_CornerAnnotaions[1].ren = vtkRenderer::New();
   m_CornerAnnotaions[1].ren->AddActor(m_CornerAnnotaions[1].cornerText);
   m_CornerAnnotaions[1].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow2()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[1].ren,true);
   
   //Render Window 3 == coronal
   m_CornerAnnotaions[2].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[2].cornerText->SetText(0, "Coronal");
   m_CornerAnnotaions[2].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[2].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[2].textProp->SetColor( 0.295, 0.295, 1.0 );
   m_CornerAnnotaions[2].cornerText->SetTextProperty( m_CornerAnnotaions[2].textProp );
   m_CornerAnnotaions[2].ren = vtkRenderer::New();
   m_CornerAnnotaions[2].ren->AddActor(m_CornerAnnotaions[2].cornerText);
   m_CornerAnnotaions[2].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow3()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[2].ren,true);
    
   /*************************************************/
 
 
   // create a slice rotator
   // m_SlicesRotator = mitk::SlicesRotator::New();
   // @TODO next line causes sure memory leak
   // rotator will be created nonetheless (will be switched on and off)
   m_SlicesRotator = mitk::SlicesRotator::New("slices-rotator");
   m_SlicesRotator->AddSliceController(
     mitkWidget1->GetSliceNavigationController() );
   m_SlicesRotator->AddSliceController(
     mitkWidget2->GetSliceNavigationController() );
   m_SlicesRotator->AddSliceController(
     mitkWidget3->GetSliceNavigationController() );
 
   // create a slice swiveller (using the same state-machine as SlicesRotator)
   m_SlicesSwiveller = mitk::SlicesSwiveller::New("slices-rotator");
   m_SlicesSwiveller->AddSliceController(
     mitkWidget1->GetSliceNavigationController() );
   m_SlicesSwiveller->AddSliceController(
     mitkWidget2->GetSliceNavigationController() );
   m_SlicesSwiveller->AddSliceController(
     mitkWidget3->GetSliceNavigationController() );
 
   //connect to the "time navigation controller": send time via sliceNavigationControllers
   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->GetRenderWindow()));
 
   //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);
 
   m_MouseModeSwitcher = mitk::MouseModeSwitcher::New( mitk::GlobalInteraction::GetInstance() );
 
   m_LastLeftClickPositionSupplier =
     mitk::CoordinateSupplier::New("navigation", NULL);
   mitk::GlobalInteraction::GetInstance()->AddListener(
     m_LastLeftClickPositionSupplier
     );
   // setup gradient background
   m_GradientBackground1 = mitk::GradientBackground::New();
   m_GradientBackground1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_GradientBackground1->Disable();
 
   m_GradientBackground2 = mitk::GradientBackground::New();
   m_GradientBackground2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_GradientBackground2->Disable();
 
   m_GradientBackground3 = mitk::GradientBackground::New();
   m_GradientBackground3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_GradientBackground3->Disable();
 
   m_GradientBackground4 = mitk::GradientBackground::New();
   m_GradientBackground4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_GradientBackground4->SetGradientColors(0.1,0.1,0.1,0.5,0.5,0.5);
   m_GradientBackground4->Enable();
 
   // setup the department logo rendering
   m_LogoRendering1 = mitk::ManufacturerLogo::New();
   m_LogoRendering1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_LogoRendering1->Disable();
 
   m_LogoRendering2 = mitk::ManufacturerLogo::New();
   m_LogoRendering2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_LogoRendering2->Disable();
 
   m_LogoRendering3 = mitk::ManufacturerLogo::New();
   m_LogoRendering3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_LogoRendering3->Disable();
 
   m_LogoRendering4 = mitk::ManufacturerLogo::New();
   m_LogoRendering4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_LogoRendering4->Enable();
 
   m_RectangleRendering1 = mitk::RenderWindowFrame::New();
   m_RectangleRendering1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_RectangleRendering1->Enable(1.0,0.0,0.0);
 
   m_RectangleRendering2 = mitk::RenderWindowFrame::New();
   m_RectangleRendering2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_RectangleRendering2->Enable(0.0,1.0,0.0);
 
   m_RectangleRendering3 = mitk::RenderWindowFrame::New();
   m_RectangleRendering3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_RectangleRendering3->Enable(0.0,0.0,1.0);
 
   m_RectangleRendering4 = mitk::RenderWindowFrame::New();
   m_RectangleRendering4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_RectangleRendering4->Enable(1.0,1.0,0.0);
 }
   
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   DisablePositionTracking();
   DisableNavigationControllerEventListening();
 
   m_TimeNavigationController->Disconnect(mitkWidget1->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget2->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget3->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget4->GetSliceNavigationController());
 
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[0].ren );
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow2()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[1].ren );
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow3()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[2].ren );
 
   //Delete CornerAnnotation
   m_CornerAnnotaions[0].cornerText->Delete();
   m_CornerAnnotaions[0].textProp->Delete();
   m_CornerAnnotaions[0].ren->Delete();
 
   m_CornerAnnotaions[1].cornerText->Delete();
   m_CornerAnnotaions[1].textProp->Delete();
   m_CornerAnnotaions[1].ren->Delete();
 
   m_CornerAnnotaions[2].cornerText->Delete();
   m_CornerAnnotaions[2].textProp->Delete();
   m_CornerAnnotaions[2].ren->Delete();
 }
 
 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
 {
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
   {
     if(m_DataStorage.IsNotNull())
     {
       m_DataStorage->Remove(m_PlaneNode1);
       m_DataStorage->Remove(m_PlaneNode2);
       m_DataStorage->Remove(m_PlaneNode3);
       m_DataStorage->Remove(m_Node);
     }
   }
 }
 
 void QmitkStdMultiWidget::AddPlanesToDataStorage()
 {
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
   {
     if (m_DataStorage.IsNotNull())
     {
       m_DataStorage->Add(m_Node);
       m_DataStorage->Add(m_PlaneNode1, m_Node);
       m_DataStorage->Add(m_PlaneNode2, m_Node);
       m_DataStorage->Add(m_PlaneNode3, m_Node);
       static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode1->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
       static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode2->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
       static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode3->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
     }
   }
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DImagesUp()
 {
   SMW_INFO << "changing layout to 2D images up... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget Container into splitter top
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit1->addWidget( mitkWidget3Container );
 
   //set SplitterSize for splitter top
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
 
   //insert Widget Container into splitter bottom
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set SplitterSize for splitter m_LayoutSplit
   splitterSize.clear();
   splitterSize.push_back(400);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   //Change Layout Name
   m_Layout = LAYOUT_2D_IMAGES_UP;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DImagesLeft()
 {
   SMW_INFO << "changing layout to 2D images left... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit1->addWidget( mitkWidget3Container );
 
   //set splitterSize of SubSplit1
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
 
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set splitterSize of Layout Split
   splitterSize.clear();
   splitterSize.push_back(400);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   //update Layout Name
   m_Layout = LAYOUT_2D_IMAGES_LEFT;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToDefault()
 {
   SMW_INFO << "changing layout to default... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget container into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_SubSplit2->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_DEFAULT;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_DEFAULT );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToBig3D()
 {
   SMW_INFO << "changing layout to big 3D ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget4Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_BIG_3D;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_BIG_3D );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget1()
 {
   SMW_INFO << "changing layout to big Widget1 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget1Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   mitkWidget2->hide();
   mitkWidget3->hide();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET1;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET1 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget2()
 {
   SMW_INFO << "changing layout to big Widget2 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget2Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET2;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET2 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget3()
 {
   SMW_INFO << "changing layout to big Widget3 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget3Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET3;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET3 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToRowWidget3And4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //add Widgets to splitter
   m_LayoutSplit->addWidget( mitkWidget3Container );
   m_LayoutSplit->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_ROW_WIDGET_3_AND_4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToColumnWidget3And4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in one Column..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //add Widgets to splitter
   m_LayoutSplit->addWidget( mitkWidget3Container );
   m_LayoutSplit->addWidget( mitkWidget4Container );
 
   //set SplitterSize
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_COLUMN_WIDGET_3_AND_4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToRowWidgetSmall3andBig4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   this->changeLayoutToRowWidget3And4();
 
   m_Layout = LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4;
 }
 
 
 void QmitkStdMultiWidget::changeLayoutToSmallUpperWidget2Big3and4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget into the splitters
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit2->setSizes( splitterSize );
   splitterSize.clear();
   splitterSize.push_back(500);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show Widget if hidden
   mitkWidget1->hide();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 
 void QmitkStdMultiWidget::changeLayoutTo2x2Dand3DWidget()
 {
   SMW_INFO << "changing layout to 2 x 2D and 3D Widget" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //add Widgets to splitter
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2X_2D_AND_3D_WIDGET;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 
 void QmitkStdMultiWidget::changeLayoutToLeft2Dand3DRight2D()
 {
   SMW_INFO << "changing layout to 2D and 3D left, 2D right Widget" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
 
   //add Widgets to splitter
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget4Container );
   m_SubSplit2->addWidget( mitkWidget2Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown()
 {
   SMW_INFO << "changing layout to 2D up and 3D down" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2  
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget Container into splitter top
   m_SubSplit1->addWidget( mitkWidget1Container );
 
   //set SplitterSize for splitter top
    QList<int> splitterSize;
 //   splitterSize.push_back(1000);
 //   splitterSize.push_back(1000);
 //   splitterSize.push_back(1000);
 //   m_SubSplit1->setSizes( splitterSize );
 
   //insert Widget Container into splitter bottom
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set SplitterSize for splitter m_LayoutSplit
   splitterSize.clear();
   splitterSize.push_back(700);
   splitterSize.push_back(700);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   mitkWidget2->hide();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2D_UP_AND_3D_DOWN;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
 
   //update all Widgets
   this->UpdateAllWidgets();
 }
 
 
 
 void QmitkStdMultiWidget::SetDataStorage( mitk::DataStorage* ds )
 {
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetDataStorage(ds);
   m_DataStorage = ds;
 }
 
 
 void QmitkStdMultiWidget::Fit()
 {
   vtkRenderer * vtkrenderer;
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetDisplayGeometry()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL ) 
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL ) 
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL ) 
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL ) 
     vtkrenderer->ResetCamera();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 
 void QmitkStdMultiWidget::InitPositionTracking()
 {
   //PoinSetNode for MouseOrientation
   m_PositionTrackerNode = mitk::DataNode::New();
   m_PositionTrackerNode->SetProperty("name", mitk::StringProperty::New("Mouse Position"));
   m_PositionTrackerNode->SetData( mitk::PointSet::New() );
   m_PositionTrackerNode->SetColor(1.0,0.33,0.0);
   m_PositionTrackerNode->SetProperty("layer", mitk::IntProperty::New(1001));
   m_PositionTrackerNode->SetVisibility(true);
   m_PositionTrackerNode->SetProperty("inputdevice", mitk::BoolProperty::New(true) );
   m_PositionTrackerNode->SetProperty("BaseRendererMapperID", mitk::IntProperty::New(0) );//point position 2D mouse
   m_PositionTrackerNode->SetProperty("baserenderer", mitk::StringProperty::New("N/A"));
 }
 
 
 void QmitkStdMultiWidget::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::Geometry2DDataMapper2D::Pointer mapper;
 
   // ... of widget 1
   m_PlaneNode1 = (mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode1->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   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));
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   m_PlaneNode2 =( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode2->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   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));
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   m_PlaneNode3 = (mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode3->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   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));
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   m_Node = mitk::DataNode::New();
   m_Node->SetProperty("name", mitk::StringProperty::New("Widgets"));
   m_Node->SetProperty("helper object", mitk::BoolProperty::New(true));
 }
 
 
 mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 
 void QmitkStdMultiWidget::EnableStandardLevelWindow()
 {
   levelWindowWidget->disconnect(this);
   levelWindowWidget->SetDataStorage(mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDataStorage());
   levelWindowWidget->show();
 }
 
 
 void QmitkStdMultiWidget::DisableStandardLevelWindow()
 {
   levelWindowWidget->disconnect(this);
   levelWindowWidget->hide();
 }
 
 
 // CAUTION: Legacy code for enabling Qt-signal-controlled view initialization.
 // Use RenderingManager::InitializeViews() instead.
 bool QmitkStdMultiWidget::InitializeStandardViews( const mitk::Geometry3D * geometry )
 {
   return m_RenderingManager->InitializeViews( geometry );
 }
 
 
 void QmitkStdMultiWidget::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(mitkWidget1->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget2->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget3->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget4->GetRenderWindow());
 }
 
 
 void QmitkStdMultiWidget::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(mitkWidget1->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget2->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget3->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget4->GetRenderWindow());
 }
 
 
 void QmitkStdMultiWidget::wheelEvent( QWheelEvent * e )
 {
   emit WheelMoved( e );
 }
 
 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent * e)
 {
    if (e->button() == Qt::LeftButton) {
        mitk::Point3D pointValue = this->GetLastLeftClickPosition();
        emit LeftMouseClicked(pointValue); 
    }
 }
 
 void QmitkStdMultiWidget::moveEvent( QMoveEvent* e )
 {
   QWidget::moveEvent( e );
   
   // it is necessary to readjust the position of the overlays as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 void QmitkStdMultiWidget::leaveEvent ( QEvent * /*e*/  )
 {
   //set cursor back to initial state
   m_SlicesRotator->ResetMouseCursor();
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
 {
   return mitkWidget1;
 }
 
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
 {
   return mitkWidget2;
 }
 
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
 {
   return mitkWidget3;
 }
 
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
 {
   return mitkWidget4;
 }
 
 
 const mitk::Point3D& QmitkStdMultiWidget::GetLastLeftClickPosition() const
 {
   return m_LastLeftClickPositionSupplier->GetCurrentPoint();
 }
 
 
 const mitk::Point3D QmitkStdMultiWidget::GetCrossPosition() const
 {
   const mitk::PlaneGeometry *plane1 =
     mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane2 =
     mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane3 =
     mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ( (plane1 != NULL) && (plane2 != NULL)
     && (plane1->IntersectionLine( plane2, line )) )
   {
     mitk::Point3D point;
     if ( (plane3 != NULL)
       && (plane3->IntersectionPoint( line, point )) )
     {
       return point;
     }
   }
   return m_LastLeftClickPositionSupplier->GetCurrentPoint();
 }
 
 
 void QmitkStdMultiWidget::EnablePositionTracking()
 {
   if (!m_PositionTracker)
   {
     m_PositionTracker = mitk::PositionTracker::New("PositionTracker", NULL);
   }
   mitk::GlobalInteraction* globalInteraction = mitk::GlobalInteraction::GetInstance();
   if (globalInteraction)
   {
     if(m_DataStorage.IsNotNull())
       m_DataStorage->Add(m_PositionTrackerNode);
     globalInteraction->AddListener(m_PositionTracker);
   }
 }
 
 
 void QmitkStdMultiWidget::DisablePositionTracking()
 {
   mitk::GlobalInteraction* globalInteraction =
     mitk::GlobalInteraction::GetInstance();
 
   if(globalInteraction)
   {
     if (m_DataStorage.IsNotNull())
       m_DataStorage->Remove(m_PositionTrackerNode);
     globalInteraction->RemoveListener(m_PositionTracker);
   }
 }
 
 
 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(
   mitk::DisplayGeometry* displayGeometry, const mitk::Point3D& p)
 {
   mitk::Point2D pointOnPlane;
   displayGeometry->Map( p, pointOnPlane );
 
   // point minus origin < width or height ==> outside ?
   mitk::Vector2D pointOnRenderWindow_MM;
   pointOnRenderWindow_MM = pointOnPlane.GetVectorFromOrigin()
     - displayGeometry->GetOriginInMM();
 
   mitk::Vector2D sizeOfDisplay( displayGeometry->GetSizeInMM() );
 
   if (   sizeOfDisplay[0] < pointOnRenderWindow_MM[0]
   ||                0 > pointOnRenderWindow_MM[0]
   || sizeOfDisplay[1] < pointOnRenderWindow_MM[1]
   ||                0 > pointOnRenderWindow_MM[1] )
   {
     // point is not visible -> move geometry
     mitk::Vector2D offset( (pointOnRenderWindow_MM - sizeOfDisplay / 2.0)
       / displayGeometry->GetScaleFactorMMPerDisplayUnit() );
 
     displayGeometry->MoveBy( offset );
   }
 }
 
 
 void QmitkStdMultiWidget::MoveCrossToPosition(const mitk::Point3D& newPosition)
 {
   // create a PositionEvent with the given position and
   // tell the slice navigation controllers to move there
 
   mitk::Point2D p2d;
   mitk::PositionEvent event( mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()), 0, 0, 0,
     mitk::Key_unknown, p2d, newPosition );
   mitk::StateEvent stateEvent(mitk::EIDLEFTMOUSEBTN, &event);
   mitk::StateEvent stateEvent2(mitk::EIDLEFTMOUSERELEASE, &event);
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     mitkWidget1->GetSliceNavigationController()->HandleEvent( &stateEvent );
     mitkWidget2->GetSliceNavigationController()->HandleEvent( &stateEvent );
     mitkWidget3->GetSliceNavigationController()->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     mitkWidget1->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     mitkWidget2->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     mitkWidget3->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     break;
 
   case PLANE_MODE_ROTATION:
     m_SlicesRotator->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     m_SlicesRotator->HandleEvent( &stateEvent2 );
     break;
 
   case PLANE_MODE_SWIVEL:
     m_SlicesSwiveller->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     m_SlicesSwiveller->HandleEvent( &stateEvent2 );
     break;
   }
 
   // determine if cross is now out of display
   // if so, move the display window
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
 
   // update displays
   m_RenderingManager->RequestUpdateAll();
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
 {
   if(!m_PendingCrosshairPositionEvent)
   {
     m_PendingCrosshairPositionEvent=true;
     QTimer::singleShot(0,this,SLOT( HandleCrosshairPositionEventDelayed() ) );
   }
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
 {
   m_PendingCrosshairPositionEvent = false;
 
   // find image with highest layer
   mitk::Point3D crosshairPos = this->GetCrossPosition();
 
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
 
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
   std::string statusText;
-  mitk::Image::Pointer image3D;
+  mitk::Image::Pointer image;
   int  maxlayer = -32768;
 
   mitk::BaseRenderer* baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
   // find image with largest layer, that is the image shown on top in the render window
   for (unsigned int x = 0; x < nodes->size(); x++)
   {
     if ( (nodes->at(x)->GetData()->GetGeometry() != NULL) &&
          nodes->at(x)->GetData()->GetGeometry()->IsInside(crosshairPos) )
     {
       int layer = 0;
       if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
       if(layer > maxlayer)
       {
         if( static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible( baseRenderer ) )
         {
-          image3D = dynamic_cast<mitk::Image*>(nodes->at(x)->GetData());
+          image = dynamic_cast<mitk::Image*>(nodes->at(x)->GetData());
           maxlayer = layer;
         }
       }
     }
   }
 
   std::stringstream stream;
 
   mitk::Index3D p;
-  if(image3D.IsNotNull())
+  int timestep = baseRenderer->GetTimeStep();
+
+  if(image.IsNotNull() && (image->GetTimeSteps() > timestep ))
   {
-    image3D->GetGeometry()->WorldToIndex(crosshairPos, p);
+    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 = image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep());
+    mitk::ScalarType pixelValue = image->GetPixelValueByIndex(p, timestep);
     if (fabs(pixelValue)>1000000)
     {
-      stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<std::scientific<<image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep())<<"  ";
+      stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<std::scientific<<image->GetPixelValueByIndex(p, timestep)<<"  ";
     }
     else
     {
-      stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep())<<"  ";
+      stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<image->GetPixelValueByIndex(p, timestep)<<"  ";
     }
   }
   else
   {
     stream << "No image information at this position!";
   }
 
   statusText = stream.str();
   mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
 
 
 }
 
 void QmitkStdMultiWidget::EnableNavigationControllerEventListening()
 {
   // Let NavigationControllers listen to GlobalInteraction
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   // Listen for SliceNavigationController
   mitkWidget1->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
   mitkWidget2->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
   mitkWidget3->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     gi->AddListener( mitkWidget1->GetSliceNavigationController() );
     gi->AddListener( mitkWidget2->GetSliceNavigationController() );
     gi->AddListener( mitkWidget3->GetSliceNavigationController() );
     gi->AddListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     gi->AddListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     gi->AddListener( m_SlicesSwiveller );
     break;
   }
 
   gi->AddListener( m_TimeNavigationController );
   m_CrosshairNavigationEnabled = true;
 }
 
 void QmitkStdMultiWidget::DisableNavigationControllerEventListening()
 {
   // Do not let NavigationControllers listen to GlobalInteraction
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     gi->RemoveListener( mitkWidget1->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget2->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget3->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     m_SlicesRotator->ResetMouseCursor();
     gi->RemoveListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     m_SlicesSwiveller->ResetMouseCursor();
     gi->RemoveListener( m_SlicesSwiveller );
     break;
   }
 
   gi->RemoveListener( m_TimeNavigationController );
   m_CrosshairNavigationEnabled = false;
 }
 
 
 int QmitkStdMultiWidget::GetLayout() const
 {
   return m_Layout;
 }
 
 bool QmitkStdMultiWidget::GetGradientBackgroundFlag() const
 {
   return m_GradientBackgroundFlag;
 }
 
 void QmitkStdMultiWidget::EnableGradientBackground()
 {
   // gradient background is by default only in widget 4, otherwise
   // interferences between 2D rendering and VTK rendering may occur.
   //m_GradientBackground1->Enable();
   //m_GradientBackground2->Enable();
   //m_GradientBackground3->Enable();
   m_GradientBackground4->Enable();
   m_GradientBackgroundFlag = true;
 }
 
 
 void QmitkStdMultiWidget::DisableGradientBackground()
 {
   //m_GradientBackground1->Disable();
   //m_GradientBackground2->Disable();
   //m_GradientBackground3->Disable();
   m_GradientBackground4->Disable();
   m_GradientBackgroundFlag = false;
 }
 
 
 void QmitkStdMultiWidget::EnableDepartmentLogo()
 {
   m_LogoRendering4->Enable();
 }
 
 
 void QmitkStdMultiWidget::DisableDepartmentLogo()
 {
   m_LogoRendering4->Disable();
 }
 
 bool QmitkStdMultiWidget::IsDepartmentLogoEnabled() const
 {
   return m_LogoRendering4->IsEnabled();
 }
 
 bool QmitkStdMultiWidget::IsCrosshairNavigationEnabled() const
 {
   return m_CrosshairNavigationEnabled;
 }
 
 
 mitk::SlicesRotator * QmitkStdMultiWidget::GetSlicesRotator() const
 {
   return m_SlicesRotator;
 }
 
 
 mitk::SlicesSwiveller * QmitkStdMultiWidget::GetSlicesSwiveller() const
 {
   return m_SlicesSwiveller;
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char* widgetName, bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_DataStorage.IsNotNull())
   {
     mitk::DataNode* n = m_DataStorage->GetNamedNode(widgetName);
     if (n != NULL)
       n->SetVisibility(visible, renderer);
   }
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
 {
   SetWidgetPlaneVisibility("widget1Plane", visible, renderer);
   SetWidgetPlaneVisibility("widget2Plane", visible, renderer);
   SetWidgetPlaneVisibility("widget3Plane", visible, renderer);
   m_RenderingManager->RequestUpdateAll();
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked)
 {
   //do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked);
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked)
 {
   //do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked( bool link )
 {
   m_SlicesRotator->SetLinkPlanes( link );
   m_SlicesSwiveller->SetLinkPlanes( link );
   emit WidgetPlanesRotationLinked( link );
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode( int userMode )
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   // first of all reset left mouse button interaction to default if PACS interaction style is active
   m_MouseModeSwitcher->SelectMouseMode( mitk::MouseModeSwitcher::MousePointer );
 
   emit WidgetNotifyNewCrossHairMode( userMode );
   
   int mode = m_PlaneMode;
   bool link = false;
   
   // Convert user interface mode to actual mode
   {
     switch(userMode)
     {
       case 0:
         mode = PLANE_MODE_SLICING;
         link = false;
         break;
       
       case 1:
         mode = PLANE_MODE_ROTATION;
         link = false;
         break;
      
       case 2:
         mode = PLANE_MODE_ROTATION;
         link = true;
         break;
      
       case 3:
         mode = PLANE_MODE_SWIVEL;
         link = false;
         break;
     }
   }
 
   // Slice rotation linked
   m_SlicesRotator->SetLinkPlanes( link );
   m_SlicesSwiveller->SetLinkPlanes( link );
 
   // Do nothing if mode didn't change
   if ( m_PlaneMode == mode )
   {
     return;
   }
 
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   // Remove listeners of previous mode
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeSlicing( false );
 
     gi->RemoveListener( mitkWidget1->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget2->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget3->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeRotation( false );
 
     m_SlicesRotator->ResetMouseCursor();
     gi->RemoveListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeSwivel( false );
 
     m_SlicesSwiveller->ResetMouseCursor();
     gi->RemoveListener( m_SlicesSwiveller );
     break;
   }
 
   // Set new mode and add corresponding listener to GlobalInteraction
   m_PlaneMode = mode;
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeSlicing( true );
 
     // Add listeners
     gi->AddListener( mitkWidget1->GetSliceNavigationController() );
     gi->AddListener( mitkWidget2->GetSliceNavigationController() );
     gi->AddListener( mitkWidget3->GetSliceNavigationController() );
     gi->AddListener( mitkWidget4->GetSliceNavigationController() );
 
     m_RenderingManager->InitializeViews();
     break;
 
   case PLANE_MODE_ROTATION:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeRotation( true );
 
     // Add listener
     gi->AddListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeSwivel( true );
 
     // Add listener
     gi->AddListener( m_SlicesSwiveller );
     break;
   }
   // Notify MainTemplate GUI that mode has changed
   emit WidgetPlaneModeChange(m_PlaneMode);
 }
 
 
 void QmitkStdMultiWidget::SetGradientBackgroundColors( const mitk::Color & upper, const mitk::Color & lower )
 {
   m_GradientBackground1->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground2->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground3->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground4->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackgroundFlag = true;
 }
 
 
 void QmitkStdMultiWidget::SetDepartmentLogoPath( const char * path )
 {
   m_LogoRendering1->SetLogoSource(path);
   m_LogoRendering2->SetLogoSource(path);
   m_LogoRendering3->SetLogoSource(path);
   m_LogoRendering4->SetLogoSource(path);
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_SLICING );
   }
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_ROTATION );
   }
 }
 
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_SWIVEL );
   }
 }
 
 void QmitkStdMultiWidget::OnLayoutDesignChanged( int layoutDesignIndex )
 {
   switch( layoutDesignIndex )
   {
   case LAYOUT_DEFAULT:
     {
       this->changeLayoutToDefault();
       break;
     }
   case LAYOUT_2D_IMAGES_UP:
     {
       this->changeLayoutTo2DImagesUp();
       break;
     }
   case LAYOUT_2D_IMAGES_LEFT:
     {
       this->changeLayoutTo2DImagesLeft();
       break;
     }
   case LAYOUT_BIG_3D:
     {
       this->changeLayoutToBig3D();
       break;
     }
   case LAYOUT_WIDGET1:
     {
       this->changeLayoutToWidget1();
       break;
     }
   case LAYOUT_WIDGET2:
     {
       this->changeLayoutToWidget2();
       break;
     }
   case LAYOUT_WIDGET3:
     {
       this->changeLayoutToWidget3();
       break;
     }
   case LAYOUT_2X_2D_AND_3D_WIDGET:
     {
       this->changeLayoutTo2x2Dand3DWidget();
       break;
     }
   case LAYOUT_ROW_WIDGET_3_AND_4:
     {
       this->changeLayoutToRowWidget3And4();
       break;
     }
   case LAYOUT_COLUMN_WIDGET_3_AND_4:
     {
       this->changeLayoutToColumnWidget3And4();
       break;
     }
   case LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4:
     {
       this->changeLayoutToRowWidgetSmall3andBig4();
       break;
     }
   case LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4:
     {
       this->changeLayoutToSmallUpperWidget2Big3and4();
       break;
     }
   case LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET:
     {
       this->changeLayoutToLeft2Dand3DRight2D();
       break;
     }
 
   };
 
 
 }
 
 void QmitkStdMultiWidget::UpdateAllWidgets()
 {
   mitkWidget1->resize( mitkWidget1Container->frameSize().width()-1, mitkWidget1Container->frameSize().height() );
   mitkWidget1->resize( mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height() );
 
   mitkWidget2->resize( mitkWidget2Container->frameSize().width()-1, mitkWidget2Container->frameSize().height() );
   mitkWidget2->resize( mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height() );
 
   mitkWidget3->resize( mitkWidget3Container->frameSize().width()-1, mitkWidget3Container->frameSize().height() );
   mitkWidget3->resize( mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height() );
 
   mitkWidget4->resize( mitkWidget4Container->frameSize().width()-1, mitkWidget4Container->frameSize().height() );
   mitkWidget4->resize( mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height() );
 
 }
 
 
 void QmitkStdMultiWidget::HideAllWidgetToolbars()
 {
   mitkWidget1->HideRenderWindowMenu();
   mitkWidget2->HideRenderWindowMenu();
   mitkWidget3->HideRenderWindowMenu();
   mitkWidget4->HideRenderWindowMenu();
 }
 
 void QmitkStdMultiWidget::ActivateMenuWidget( bool state )
 {
   mitkWidget1->ActivateMenuWidget( state, this );
   mitkWidget2->ActivateMenuWidget( state, this );
   mitkWidget3->ActivateMenuWidget( state, this );
   mitkWidget4->ActivateMenuWidget( state, this );
 }
 
 bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const
 {
   return mitkWidget1->GetActivateMenuWidgetFlag();
 }
  
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   if (m_DataStorage.IsNotNull())
   {
     mitk::NodePredicateNot::Pointer pred
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(false)));
 
     mitk::NodePredicateNot::Pointer pred2
     = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
     , mitk::BoolProperty::New(true)));
 
     mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetSubset(pred);
     mitk::DataStorage::SetOfObjects::ConstPointer rs2 = m_DataStorage->GetSubset(pred2);
     // calculate bounding geometry of these nodes
     mitk::TimeSlicedGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(rs, "visible");
     
     m_RenderingManager->InitializeViews(bounds);
     //m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
     // reset interactor to normal slicing
     this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
   }
 }
 
 void QmitkStdMultiWidget::EnableColoredRectangles()
 {
   m_RectangleRendering1->Enable(1.0, 0.0, 0.0);
   m_RectangleRendering2->Enable(0.0, 1.0, 0.0);
   m_RectangleRendering3->Enable(0.0, 0.0, 1.0);
   m_RectangleRendering4->Enable(1.0, 1.0, 0.0);
 }
 
 void QmitkStdMultiWidget::DisableColoredRectangles()
 {
   m_RectangleRendering1->Disable();
   m_RectangleRendering2->Disable();
   m_RectangleRendering3->Disable();
   m_RectangleRendering4->Disable();
 }
 
 bool QmitkStdMultiWidget::IsColoredRectanglesEnabled() const
 {
   return m_RectangleRendering1->IsEnabled();
 }
 
 mitk::MouseModeSwitcher* QmitkStdMultiWidget::GetMouseModeSwitcher()
 {
   return m_MouseModeSwitcher;
 }
 
 void QmitkStdMultiWidget::MouseModeSelected( mitk::MouseModeSwitcher::MouseMode mouseMode )
 {
   if ( mouseMode == 0 )
   {
     this->EnableNavigationControllerEventListening();
   }
   else
   {
     this->DisableNavigationControllerEventListening();
   }
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1()
 {
   return this->m_PlaneNode1;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2()
 {
   return this->m_PlaneNode2;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3()
 {
   return this->m_PlaneNode3;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(int id)
 {
   switch(id)
   {
     case 1: return this->m_PlaneNode1;
     break;
     case 2: return this->m_PlaneNode2;
     break;
     case 3: return this->m_PlaneNode3;
     break;
     default: return NULL;
   }
 }
 
diff --git a/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialog.cpp b/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialog.cpp
index 52578f7ca2..f46598e694 100644
--- a/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialog.cpp
+++ b/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialog.cpp
@@ -1,76 +1,77 @@
 /*===================================================================
 
 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 "QmitkAboutDialog.h"
 #include "QmitkModulesDialog.h"
 #include <QPushButton>
 #include <mitkVersion.h>
 
 QmitkAboutDialog::QmitkAboutDialog(QWidget* parent, Qt::WindowFlags f)
   : QDialog(parent, f)
 {
   m_GUI.setupUi(this);
 
   QString mitkRevision(MITK_REVISION);
+  QString mitkRevisionDescription(MITK_REVISION_DESC);
 
-  m_GUI.m_RevisionLabel->setText(m_GUI.m_RevisionLabel->text().arg(mitkRevision));
+  m_GUI.m_RevisionLabel->setText(m_GUI.m_RevisionLabel->text().arg(mitkRevision).arg(mitkRevisionDescription));
 
   QPushButton* btnModules = new QPushButton(QIcon(":/qmitk/ModuleView.png"), "Modules");
   m_GUI.m_ButtonBox->addButton(btnModules, QDialogButtonBox::ActionRole);
 
   connect(btnModules, SIGNAL(clicked()), this, SLOT(ShowModules()));
   connect(m_GUI.m_ButtonBox, SIGNAL(rejected()), this, SLOT(reject()));
 }
 
 QmitkAboutDialog::~QmitkAboutDialog()
 {
 }
 
 void QmitkAboutDialog::ShowModules()
 {
   QmitkModulesDialog dialog(this);
   dialog.exec();
 }
 
 QString QmitkAboutDialog::GetAboutText() const
 {
   return m_GUI.m_AboutLabel->text();
 }
 
 QString QmitkAboutDialog::GetCaptionText() const
 {
   return m_GUI.m_CaptionLabel->text();
 }
 
 QString QmitkAboutDialog::GetRevisionText() const
 {
   return m_GUI.m_RevisionLabel->text();
 }
 
 void QmitkAboutDialog::SetAboutText(const QString &text)
 {
   m_GUI.m_AboutLabel->setText(text);
 }
 
 void QmitkAboutDialog::SetCaptionText(const QString &text)
 {
   m_GUI.m_CaptionLabel->setText(text);
 }
 
 void QmitkAboutDialog::SetRevisionText(const QString &text)
 {
   m_GUI.m_RevisionLabel->setText(text);
 }
diff --git a/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialogGUI.ui b/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialogGUI.ui
index 52569abe7b..1aa16621d5 100644
--- a/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialogGUI.ui
+++ b/Modules/QmitkExt/QmitkAboutDialog/QmitkAboutDialogGUI.ui
@@ -1,166 +1,167 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkAboutDialog</class>
  <widget class="QDialog" name="QmitkAboutDialog">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>534</width>
     <height>397</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>About</string>
   </property>
   <property name="autoFillBackground">
    <bool>false</bool>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <layout class="QVBoxLayout" name="verticalLayout">
        <item>
         <widget class="QLabel" name="m_CaptionLabel">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="font">
           <font>
            <family>MS Sans Serif</family>
            <pointsize>48</pointsize>
            <weight>75</weight>
            <bold>true</bold>
           </font>
          </property>
          <property name="text">
           <string>MITK</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft</set>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="m_RevisionLabel">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
-          <string>Revision %1</string>
+          <string>Revision %1
+Description %2</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeType">
         <enum>QSizePolicy::Expanding</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QLabel" name="m_LogoLabel">
        <property name="maximumSize">
         <size>
          <width>84</width>
          <height>56</height>
         </size>
        </property>
        <property name="text">
         <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;a href=&quot;http://www.dkfz.de/en/mbi/&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;&lt;img src=&quot;:/qmitk/Logo_mbiATdkfz_small.png&quot; /&gt;&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
        </property>
        <property name="scaledContents">
         <bool>true</bool>
        </property>
        <property name="openExternalLinks">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QScrollArea" name="scrollArea">
      <property name="widgetResizable">
       <bool>true</bool>
      </property>
      <widget class="QWidget" name="m_ScrollArea">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>-51</y>
         <width>496</width>
         <height>375</height>
        </rect>
       </property>
       <layout class="QGridLayout" name="gridLayout">
        <item row="0" column="1">
         <widget class="QLabel" name="m_AboutLabel">
          <property name="text">
           <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:'Ubuntu'; font-size:11pt; 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:10pt; font-weight:600;&quot;&gt;General Information&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;br /&gt;&lt;/p&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-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;MITK [1] has been developed by the Division of Medical and Biological Informatics of the German Cancer Research Center (DKFZ).&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;&lt;br /&gt;&lt;/p&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-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;[1] &lt;/span&gt;&lt;a href=&quot;http://www.mitk.org/&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; text-decoration: underline; color:#0000ff;&quot;&gt;http://www.mitk.org/&lt;/span&gt;&lt;/a&gt;&lt;/p&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-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;[2] &lt;/span&gt;&lt;a href=&quot;http://www.dkfz.de/en/mbi/index.html&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; text-decoration: underline; color:#0000ff;&quot;&gt;http://www.dkfz.de/en/mbi/index.html&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;&lt;br /&gt;&lt;/p&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-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;To contact the MITK Team, see &lt;/span&gt;&lt;a href=&quot;http://www.mitk.org/wiki/Contact&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; text-decoration: underline; color:#0000ff;&quot;&gt;http://www.mitk.org/wiki/Contact&lt;/span&gt;&lt;/a&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;.&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;br /&gt;&lt;/p&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-family:'MS Shell Dlg 2'; font-size:10pt; font-weight:600;&quot;&gt;Third Party Libraries&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'MS Shell Dlg 2'; font-size:8pt;&quot;&gt;&lt;br /&gt;&lt;/p&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;a href=&quot;http://docs.mitk.org/nightly-qt4/thirdpartylibs.html&quot;&gt;&lt;span style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; text-decoration: underline; color:#0000ff;&quot;&gt;http://docs.mitk.org/nightly-qt4/thirdpartylibs.html&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'MS Shell Dlg 2'; font-size:8pt; text-decoration: underline; color:#0000ff;&quot;&gt;&lt;br /&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
          </property>
          <property name="openExternalLinks">
           <bool>true</bool>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item>
     <widget class="QDialogButtonBox" name="m_ButtonBox">
      <property name="standardButtons">
       <set>QDialogButtonBox::Close</set>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>
diff --git a/Modules/QmitkExt/QmitkSlicesInterpolator.cpp b/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
index 0833932c65..c176ec221f 100644
--- a/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
+++ b/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
@@ -1,1066 +1,1074 @@
 /*===================================================================
 
 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 "QmitkSlicesInterpolator.h"
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkSelectableGLWidget.h"
 
 #include "mitkToolManager.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkProgressBar.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include "mitkInteractionConst.h"
 #include "mitkApplyDiffImageOperation.h"
 #include "mitkDiffImageApplier.h"
 #include "mitkSegTool2D.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkSurfaceToImageFilter.h"
 
 #include <itkCommand.h>
 
 #include <QCheckBox>
 #include <QPushButton>
 #include <QMenu>
 #include <QCursor>
 #include <QHBoxLayout>
 #include <QMessageBox>
 
 
 #define ROUND(a)     ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 const std::map<QAction*, unsigned int> QmitkSlicesInterpolator::createActionToSliceDimension()
 {
   std::map<QAction*, unsigned int> actionToSliceDimension;
   actionToSliceDimension[new QAction("Axial (red window)", 0)] = 2;
   actionToSliceDimension[new QAction("Sagittal (green window)", 0)] = 0;
   actionToSliceDimension[new QAction("Coronal (blue window)", 0)] = 1;
   return actionToSliceDimension;
 }
 
 
 QmitkSlicesInterpolator::QmitkSlicesInterpolator(QWidget* parent, const char*  /*name*/)
   :QWidget(parent),
     ACTION_TO_SLICEDIMENSION( createActionToSliceDimension() ),
     m_Interpolator( mitk::SegmentationInterpolationController::New() ),
     m_MultiWidget(NULL),
     m_ToolManager(NULL),
     m_Initialized(false),
     m_LastSliceDimension(2),
     m_LastSliceIndex(0),
     m_2DInterpolationEnabled(false),
     m_3DInterpolationEnabled(false)
 {
 
   m_SurfaceInterpolator = mitk::SurfaceInterpolationController::GetInstance();
   QHBoxLayout* layout = new QHBoxLayout(this);
 
   m_GroupBoxEnableExclusiveInterpolationMode = new QGroupBox("Interpolation", this);
   QGridLayout* grid = new QGridLayout(m_GroupBoxEnableExclusiveInterpolationMode);
 
   m_RBtnEnable3DInterpolation = new QRadioButton("3D",this);
   connect(m_RBtnEnable3DInterpolation, SIGNAL(toggled(bool)), this, SLOT(On3DInterpolationEnabled(bool)));
   m_RBtnEnable3DInterpolation->setChecked(true);
   grid->addWidget(m_RBtnEnable3DInterpolation,0,0);
 
   m_BtnAccept3DInterpolation = new QPushButton("Accept", this);
   m_BtnAccept3DInterpolation->setEnabled(false);
   connect(m_BtnAccept3DInterpolation, SIGNAL(clicked()), this, SLOT(OnAccept3DInterpolationClicked()));
   grid->addWidget(m_BtnAccept3DInterpolation, 0,1);
 
   m_CbShowMarkers = new QCheckBox("Show Position Nodes", this);
   m_CbShowMarkers->setChecked(true);
   connect(m_CbShowMarkers, SIGNAL(toggled(bool)), this, SLOT(OnShowMarkers(bool)));
   connect(m_CbShowMarkers, SIGNAL(toggled(bool)), this, SIGNAL(SignalShowMarkerNodes(bool)));
   grid->addWidget(m_CbShowMarkers,0,2);
 
   m_RBtnEnable2DInterpolation = new QRadioButton("2D",this);
   connect(m_RBtnEnable2DInterpolation, SIGNAL(toggled(bool)), this, SLOT(On2DInterpolationEnabled(bool)));
   grid->addWidget(m_RBtnEnable2DInterpolation,1,0);
 
   m_BtnAcceptInterpolation = new QPushButton("Accept", this);
   m_BtnAcceptInterpolation->setEnabled( false );
   connect( m_BtnAcceptInterpolation, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()) );
   grid->addWidget(m_BtnAcceptInterpolation,1,1);
 
   m_BtnAcceptAllInterpolations = new QPushButton("... for all slices", this);
   m_BtnAcceptAllInterpolations->setEnabled( false );
   connect( m_BtnAcceptAllInterpolations, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()) );
   grid->addWidget(m_BtnAcceptAllInterpolations,1,2);
 
   m_RBtnDisableInterpolation = new QRadioButton("Disable", this);
   connect(m_RBtnDisableInterpolation, SIGNAL(toggled(bool)), this, SLOT(OnInterpolationDisabled(bool)));
   grid->addWidget(m_RBtnDisableInterpolation, 2,0);
 
   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 );
 
   // 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(255.0,255.0,0.0) );
   m_InterpolatedSurfaceNode->SetProperty( "name", mitk::StringProperty::New("Surface Interpolation feedback") );
   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->SetProperty( "color", mitk::ColorProperty::New(0.0, 0.0, 0.0) );
   m_3DContourNode->SetProperty("helper 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.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")));
   m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
 
   QWidget::setContentsMargins(0, 0, 0, 0);
   if ( QWidget::layout() != NULL )
   {
     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(SurfaceInterpolationFinished()));
   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& storage )
 {
   m_DataStorage = &storage;
   m_SurfaceInterpolator->SetDataStorage(storage);
 }
 
 mitk::DataStorage* QmitkSlicesInterpolator::GetDataStorage()
 {
   if ( m_DataStorage.IsNotNull() )
   {
     return m_DataStorage;
   }
   else
   {
     return NULL;
   }
 }
 
 
 void QmitkSlicesInterpolator::Initialize(mitk::ToolManager* toolManager, QmitkStdMultiWidget* multiWidget)
 {
   if (m_Initialized)
   {
     // remove old observers
     if (m_ToolManager)
     {
       m_ToolManager->WorkingDataChanged
           -= mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified );
 
       m_ToolManager->ReferenceDataChanged
           -= mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified );
     }
 
     if (m_MultiWidget)
     {
       disconnect( m_MultiWidget, SIGNAL(destroyed(QObject*)), this, SLOT(OnMultiWidgetDeleted(QObject*)) );
       mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
       slicer->RemoveObserver( TSliceObserverTag );
       slicer->RemoveObserver( TTimeObserverTag );
       slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
       slicer->RemoveObserver( SSliceObserverTag );
       slicer->RemoveObserver( STimeObserverTag );
       slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
       slicer->RemoveObserver( FSliceObserverTag );
       slicer->RemoveObserver( FTimeObserverTag );
     }
 
     //return;
   }
 
   m_MultiWidget = multiWidget;
 
   connect( m_MultiWidget, SIGNAL(destroyed(QObject*)), this, SLOT(OnMultiWidgetDeleted(QObject*)) );
 
   m_ToolManager = toolManager;
 
   if (m_ToolManager)
   {
     // set enabled only if a segmentation is selected
     mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
     QWidget::setEnabled( node != NULL );
 
     // 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 steppers of the three multi widget widgets. after each change, call the interpolator
     if (m_MultiWidget)
     {
       mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
       m_TimeStep.resize(3);
       m_TimeStep[2] = slicer->GetTime()->GetPos();
       {
         itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnAxialTimeChanged );
         TTimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
       }
 
       {
         itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnAxialSliceChanged );
         TSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
       }
 
       // connect to the steppers of the three multi widget widgets. after each change, call the interpolator
       slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
       m_TimeStep[0] = slicer->GetTime()->GetPos();
       {
         itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSagittalTimeChanged );
         STimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
       }
 
       {
         itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSagittalSliceChanged );
         SSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
       }
 
       // connect to the steppers of the three multi widget widgets. after each change, call the interpolator
       slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
       m_TimeStep[1] = slicer->GetTime()->GetPos();
       {
         itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnFrontalTimeChanged );
         FTimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
       }
 
       {
         itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
         command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnFrontalSliceChanged );
         FSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
       }
     }
   }
 
   m_Initialized = true;
 }
 
 QmitkSlicesInterpolator::~QmitkSlicesInterpolator()
 {
   if (m_MultiWidget)
   {
     mitk::SliceNavigationController* slicer;
     if(m_MultiWidget->mitkWidget1 != NULL)
     {
       slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
       slicer->RemoveObserver( TSliceObserverTag );
       slicer->RemoveObserver( TTimeObserverTag );
     }
     if(m_MultiWidget->mitkWidget2 != NULL)
     {
       slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
       slicer->RemoveObserver( SSliceObserverTag );
       slicer->RemoveObserver( STimeObserverTag );
     }
     if(m_MultiWidget->mitkWidget3 != NULL)
     {
       slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
       slicer->RemoveObserver( FSliceObserverTag );
       slicer->RemoveObserver( FTimeObserverTag );
     }
   }
   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( InterpolationInfoChangedObserverTag );
   m_SurfaceInterpolator->RemoveObserver( SurfaceInterpolationInfoChangedObserverTag );
 
   delete m_Timer;
 }
 
 void QmitkSlicesInterpolator::On2DInterpolationEnabled(bool status)
 {
   OnInterpolationActivated(status);
 }
 
 void QmitkSlicesInterpolator::On3DInterpolationEnabled(bool status)
 {
   On3DInterpolationActivated(status);
 }
 
 void QmitkSlicesInterpolator::OnInterpolationDisabled(bool status)
 {
   if (status)
   {
     OnInterpolationActivated(!status);
     On3DInterpolationActivated(!status);
     this->Show3DInterpolationResult(false);
   }
 }
 
 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()
 {
   //Check if the new working data has already a contourlist for 3D interpolation
   this->SetCurrentContourListID();
   if (m_2DInterpolationEnabled)
   {
     OnInterpolationActivated( true ); // re-initialize if needed
   }
   if (m_3DInterpolationEnabled)
   {
     On3DInterpolationActivated( true);
   }
 }
 
 void QmitkSlicesInterpolator::OnToolManagerReferenceDataModified()
 {
   if (m_2DInterpolationEnabled)
   {
     OnInterpolationActivated( true ); // re-initialize if needed
   }
   if (m_3DInterpolationEnabled)
   {
     this->Show3DInterpolationResult(false);
   }
 }
 
 void QmitkSlicesInterpolator::OnAxialTimeChanged(itk::Object* sender, const itk::EventObject& e)
 {
   const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
   m_TimeStep[2] = event.GetPos();
 
   if (m_LastSliceDimension == 2)
   {
     mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
     if (snc) snc->SendSlice(); // will trigger a new interpolation
   }
 }
 
 void QmitkSlicesInterpolator::OnTransversalTimeChanged(itk::Object* sender, const itk::EventObject& e)
 {
   this->OnAxialTimeChanged(sender, e);
 }
 
 void QmitkSlicesInterpolator::OnSagittalTimeChanged(itk::Object* sender, const itk::EventObject& e)
 {
   const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
   m_TimeStep[0] = event.GetPos();
 
   if (m_LastSliceDimension == 0)
   {
     mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
     if (snc) snc->SendSlice(); // will trigger a new interpolation
   }
 }
 
 void QmitkSlicesInterpolator::OnFrontalTimeChanged(itk::Object* sender, const itk::EventObject& e)
 {
   const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
   m_TimeStep[1] = event.GetPos();
 
   if (m_LastSliceDimension == 1)
   {
     mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
     if (snc) snc->SendSlice(); // will trigger a new interpolation
   }
 }
 
 void QmitkSlicesInterpolator::OnAxialSliceChanged(const itk::EventObject& e)
 {
   if ( TranslateAndInterpolateChangedSlice( e, 2 ) )
   {
     if (m_MultiWidget)
     {
       mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget1->GetRenderWindow())->RequestUpdate();
     }
   }
 }
 
 void QmitkSlicesInterpolator::OnTransversalSliceChanged(const itk::EventObject& e)
 {
   this->OnAxialSliceChanged(e);
 }
 
 void QmitkSlicesInterpolator::OnSagittalSliceChanged(const itk::EventObject& e)
 {
   if ( TranslateAndInterpolateChangedSlice( e, 0 ) )
   {
     if (m_MultiWidget)
     {
       mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget2->GetRenderWindow())->RequestUpdate();
     }
   }
 }
 
 void QmitkSlicesInterpolator::OnFrontalSliceChanged(const itk::EventObject& e)
 {
   if ( TranslateAndInterpolateChangedSlice( e, 1 ) )
   {
     if (m_MultiWidget)
     {
       mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget3->GetRenderWindow())->RequestUpdate();
     }
   }
 }
 
 bool QmitkSlicesInterpolator::TranslateAndInterpolateChangedSlice(const itk::EventObject& e, unsigned int windowID)
 {
   if (!m_2DInterpolationEnabled) return false;
 
   try
   {
     const mitk::SliceNavigationController::GeometrySliceEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent&>(e);
 
     mitk::TimeSlicedGeometry* tsg = event.GetTimeSlicedGeometry();
     if (tsg && m_TimeStep.size() > windowID)
     {
       mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(tsg->GetGeometry3D(m_TimeStep[windowID]));
       if (slicedGeometry)
       {
         mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( event.GetPos() ));
         if (plane)
           Interpolate( plane, m_TimeStep[windowID] );
         return true;
       }
     }
   }
   catch(std::bad_cast)
   {
     return false; // so what
   }
 
   return false;
 }
 
 void QmitkSlicesInterpolator::Interpolate( mitk::PlaneGeometry* plane, unsigned int timeStep )
 {
   if (m_ToolManager)
   {
     mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
     if (node)
     {
       m_Segmentation = dynamic_cast<mitk::Image*>(node->GetData());
       if (m_Segmentation)
       {
         int clickedSliceDimension(-1);
         int clickedSliceIndex(-1);
 
         // calculate real slice position, i.e. slice of the image and not slice of the TimeSlicedGeometry
         mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, clickedSliceDimension, clickedSliceIndex );
         mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( clickedSliceDimension, clickedSliceIndex, timeStep );
         m_FeedbackNode->SetData( interpolation );
 
         // Workaround for Bug 11318
         if ((interpolation.IsNotNull()) && (interpolation->GetGeometry() != NULL))
         {
           if(clickedSliceDimension == 1)
           {
             mitk::Point3D orig = interpolation->GetGeometry()->GetOrigin();
             orig[0] = orig[0];
             orig[1] = orig[1] + 0.5;
             orig[2] = orig[2];
             interpolation->GetGeometry()->SetOrigin(orig);
           }
         }
 
         // Workaround for Bug 11318 END
 
         m_LastSliceDimension = clickedSliceDimension;
         m_LastSliceIndex = clickedSliceIndex;
       }
     }
   }
 }
 
 void QmitkSlicesInterpolator::SurfaceInterpolationFinished()
 {
   mitk::Surface::Pointer interpolatedSurface = m_SurfaceInterpolator->GetInterpolationResult();
 
   if(interpolatedSurface.IsNotNull())
   {
     m_BtnAccept3DInterpolation->setEnabled(true);
     m_InterpolatedSurfaceNode->SetData(interpolatedSurface);
     m_3DContourNode->SetData(m_SurfaceInterpolator->GetContoursAsSurface());
 
     this->Show3DInterpolationResult(true);
 
     if( !m_DataStorage->Exists(m_InterpolatedSurfaceNode) && !m_DataStorage->Exists(m_3DContourNode))
     {
       m_DataStorage->Add(m_3DContourNode);
       m_DataStorage->Add(m_InterpolatedSurfaceNode);
 
     }
   }
   else if (interpolatedSurface.IsNull())
   {
     m_BtnAccept3DInterpolation->setEnabled(false);
 
     if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
     {
       this->Show3DInterpolationResult(false);
     }
   }
 
   if (m_MultiWidget)
   {
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSlicesInterpolator::OnAcceptInterpolationClicked()
 {
   if (m_Segmentation && m_FeedbackNode->GetData())
   {
     //making interpolation separately undoable
     mitk::UndoStackItem::IncCurrObjectEventId();
     mitk::UndoStackItem::IncCurrGroupEventId();
     mitk::UndoStackItem::ExecuteIncrement();
 
     mitk::OverwriteSliceImageFilter::Pointer slicewriter = mitk::OverwriteSliceImageFilter::New();
     slicewriter->SetInput( m_Segmentation );
     slicewriter->SetCreateUndoInformation( true );
     slicewriter->SetSliceImage( dynamic_cast<mitk::Image*>(m_FeedbackNode->GetData()) );
     slicewriter->SetSliceDimension( m_LastSliceDimension );
     slicewriter->SetSliceIndex( m_LastSliceIndex );
     slicewriter->SetTimeStep( m_TimeStep[m_LastSliceDimension] );
     slicewriter->Update();
     m_FeedbackNode->SetData(NULL);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSlicesInterpolator::AcceptAllInterpolations(unsigned int windowID)
 {
   // first creates a 3D diff image, then applies this diff to the segmentation
   if (m_Segmentation)
   {
     int sliceDimension(-1);
     int dummySliceIndex(-1);
     if (!GetSliceForWindowsID(windowID, sliceDimension, dummySliceIndex))
     {
       return; // cannot determine slice orientation
     }
 
     //making interpolation separately undoable
     mitk::UndoStackItem::IncCurrObjectEventId();
     mitk::UndoStackItem::IncCurrGroupEventId();
     mitk::UndoStackItem::ExecuteIncrement();
 
     // create a diff image for the undo operation
     mitk::Image::Pointer diffImage = mitk::Image::New();
     diffImage->Initialize( m_Segmentation );
     mitk::PixelType pixelType( mitk::MakeScalarPixelType<short signed int>()  );
     diffImage->Initialize( pixelType, 3, m_Segmentation->GetDimensions() );
 
     memset( diffImage->GetData(), 0, (pixelType.GetBpe() >> 3) * diffImage->GetDimension(0) * diffImage->GetDimension(1) * diffImage->GetDimension(2) );
     // now the diff image is all 0
 
     unsigned int timeStep( m_TimeStep[windowID] );
 
     // a slicewriter to create the diff image
     mitk::OverwriteSliceImageFilter::Pointer diffslicewriter = mitk::OverwriteSliceImageFilter::New();
     diffslicewriter->SetCreateUndoInformation( false );
     diffslicewriter->SetInput( diffImage );
     diffslicewriter->SetSliceDimension( sliceDimension );
     diffslicewriter->SetTimeStep( timeStep );
 
     unsigned int totalChangedSlices(0);
     unsigned int zslices = m_Segmentation->GetDimension( sliceDimension );
     mitk::ProgressBar::GetInstance()->AddStepsToDo(zslices);
     for (unsigned int sliceIndex = 0; sliceIndex < zslices; ++sliceIndex)
     {
       mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( sliceDimension, sliceIndex, timeStep );
       if (interpolation.IsNotNull()) // we don't check if interpolation is necessary/sensible - but m_Interpolator does
       {
         diffslicewriter->SetSliceImage( interpolation );
         diffslicewriter->SetSliceIndex( sliceIndex );
         diffslicewriter->Update();
         ++totalChangedSlices;
       }
       mitk::ProgressBar::GetInstance()->Progress();
     }
 
     if (totalChangedSlices > 0)
     {
       // store undo stack items
       if ( true )
       {
         // create do/undo operations (we don't execute the doOp here, because it has already been executed during calculation of the diff image
         mitk::ApplyDiffImageOperation* doOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
         mitk::ApplyDiffImageOperation* undoOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
         undoOp->SetFactor( -1.0 );
         std::stringstream comment;
         comment << "Accept all interpolations (" << totalChangedSlices << ")";
         mitk::OperationEvent* undoStackItem = new mitk::OperationEvent( mitk::DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, comment.str() );
         mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
 
         // acutally apply the changes here
         mitk::DiffImageApplier::GetInstanceForUndo()->ExecuteOperation( doOp );
       }
     }
 
     m_FeedbackNode->SetData(NULL);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSlicesInterpolator::FinishInterpolation(int windowID)
 {
   //this redirect is for calling from outside
 
   if (windowID < 0)
     OnAcceptAllInterpolationsClicked();
   else
     AcceptAllInterpolations( (unsigned int)windowID );
 }
 
 void QmitkSlicesInterpolator::OnAcceptAllInterpolationsClicked()
 {
   QMenu orientationPopup(this);
   std::map<QAction*, unsigned int>::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()
 {
   if (m_InterpolatedSurfaceNode.IsNotNull() && m_InterpolatedSurfaceNode->GetData())
   {
     mitk::SurfaceToImageFilter::Pointer s2iFilter = mitk::SurfaceToImageFilter::New();
     s2iFilter->MakeOutputBinaryOn();
     s2iFilter->SetInput(dynamic_cast<mitk::Surface*>(m_InterpolatedSurfaceNode->GetData()));
     s2iFilter->SetImage(dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData()));
     s2iFilter->Update();
 
     mitk::DataNode* segmentationNode = m_ToolManager->GetWorkingData(0);
     segmentationNode->SetData(s2iFilter->GetOutput());
     m_RBtnDisableInterpolation->setChecked(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     this->Show3DInterpolationResult(false);
   }
 }
 
 void QmitkSlicesInterpolator::OnAcceptAllPopupActivated(QAction* action)
 {
   try
   {
     std::map<QAction*, unsigned int>::const_iterator iter = ACTION_TO_SLICEDIMENSION.find( action );
     if (iter != ACTION_TO_SLICEDIMENSION.end())
     {
       int windowID = iter->second;
       AcceptAllInterpolations( windowID );
     }
 
   }
   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 );
       }
       //else
       //{
       //  m_DataStorage->Remove( 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 != NULL );
 
     m_BtnAcceptAllInterpolations->setEnabled( on );
     m_BtnAcceptInterpolation->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 NULL
         }
       }
     }
   }
 
   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(255.0,255.0,0.0));
   mitk::RenderingManager::GetInstance()->RequestUpdate(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetRenderWindow());
 }
 
 void QmitkSlicesInterpolator::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.widget4"))->GetRenderWindow());
 }
 
 void QmitkSlicesInterpolator::On3DInterpolationActivated(bool on)
 {
   m_3DInterpolationEnabled = on;
 
   try
   {
     if ( m_DataStorage.IsNotNull() && m_ToolManager && m_3DInterpolationEnabled)
     {
       mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
 
       if (workingNode)
       {
         bool isInterpolationResult(false);
         workingNode->GetBoolProperty("3DInterpolationResult",isInterpolationResult);
 
         if ((workingNode->IsSelected() &&
              workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")))) &&
             !isInterpolationResult && m_3DInterpolationEnabled)
         {
           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_RBtnDisableInterpolation->toggle();
           }
         }
         else if (!m_3DInterpolationEnabled)
         {
           this->Show3DInterpolationResult(false);
           m_BtnAccept3DInterpolation->setEnabled(m_3DInterpolationEnabled);
         }
       }
       else
       {
         QWidget::setEnabled( false );
         m_CbShowMarkers->setEnabled(m_3DInterpolationEnabled);
       }
     }
+    if (!m_3DInterpolationEnabled)
+    {
+       this->Show3DInterpolationResult(false);
+       m_BtnAccept3DInterpolation->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()
 {
   if (m_2DInterpolationEnabled)
   {
     // determine which one is the current view, try to do an initial interpolation
     mitk::BaseRenderer* renderer = mitk::GlobalInteraction::GetInstance()->GetFocus();
     if (renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
     {
       const mitk::TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>( renderer->GetWorldGeometry() );
       if (timeSlicedGeometry)
       {
         mitk::SliceNavigationController::GeometrySliceEvent event( const_cast<mitk::TimeSlicedGeometry*>(timeSlicedGeometry), renderer->GetSlice() );
 
         if ( renderer->GetCurrentWorldGeometry2DNode() )
         {
           if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane1() )
           {
             TranslateAndInterpolateChangedSlice( event, 2 );
           }
           else if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane2() )
           {
             TranslateAndInterpolateChangedSlice( event, 0 );
           }
           else if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane3() )
           {
             TranslateAndInterpolateChangedSlice( event, 1 );
           }
         }
       }
     }
   }
 
   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::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);
   }
 }
 
 bool QmitkSlicesInterpolator::GetSliceForWindowsID(unsigned windowID, int& sliceDimension, int& sliceIndex)
 {
   mitk::BaseRenderer* renderer(NULL);
 
   // find sliceDimension for windowID:
   //   windowID 2: axial window = renderWindow1
   //   windowID 1: frontal window = renderWindow3
   //   windowID 0: sagittal window = renderWindow2
   if ( m_MultiWidget )
   {
     switch (windowID)
     {
     case 2:
     default:
       renderer = m_MultiWidget->mitkWidget1->GetRenderer();
       break;
     case 1:
       renderer = m_MultiWidget->mitkWidget3->GetRenderer();
       break;
     case 0:
       renderer = m_MultiWidget->mitkWidget2->GetRenderer();
       break;
     }
   }
 
   if ( m_Segmentation && renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
   {
     const mitk::TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>( renderer->GetWorldGeometry() );
     if (timeSlicedGeometry)
     {
       mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(timeSlicedGeometry->GetGeometry3D(m_TimeStep[windowID]));
       if (slicedGeometry)
       {
         mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( renderer->GetSlice() ));
         Interpolate( plane, m_TimeStep[windowID] );
         return mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, sliceDimension, sliceIndex );
       }
     }
   }
 
   return false;
 }
 
 void QmitkSlicesInterpolator::OnMultiWidgetDeleted(QObject*)
 {
   if (m_MultiWidget)
   {
     m_MultiWidget = NULL;
   }
 }
 
 void QmitkSlicesInterpolator:: SetCurrentContourListID()
 {
   if ( m_DataStorage.IsNotNull() && m_ToolManager )
   {
     mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
 
     if (workingNode)
     {
       int listID;
       bool isInterpolationResult(false);
       workingNode->GetBoolProperty("3DInterpolationResult",isInterpolationResult);
 
       if ((workingNode->IsSelected() &&
            workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")))) &&
           !isInterpolationResult)
       {
         QWidget::setEnabled( true );
         if (workingNode->GetIntProperty("3DInterpolationListID", listID))
         {
           m_SurfaceInterpolator->SetCurrentListID(listID);
         }
         else
         {
           listID = m_SurfaceInterpolator->CreateNewContourList();
           workingNode->SetIntProperty("3DInterpolationListID", listID);
           this->Show3DInterpolationResult(false);
           m_BtnAccept3DInterpolation->setEnabled(false);
         }
 
         mitk::Vector3D spacing = workingNode->GetData()->GetGeometry( m_MultiWidget->GetRenderWindow3()->GetRenderer()->GetTimeStep() )->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_SurfaceInterpolator->SetWorkingImage(dynamic_cast<mitk::Image*>(workingNode->GetData()));
         m_SurfaceInterpolator->SetMaxSpacing(maxSpacing);
         m_SurfaceInterpolator->SetMinSpacing(minSpacing);
         m_SurfaceInterpolator->SetDistanceImageVolume(50000);
       }
     }
   }
 }
 
 void QmitkSlicesInterpolator::Show3DInterpolationResult(bool status)
 {
-  m_InterpolatedSurfaceNode->SetVisibility(status);
-  m_3DContourNode->SetVisibility(status, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
+   if (m_InterpolatedSurfaceNode.IsNotNull())
+      m_InterpolatedSurfaceNode->SetVisibility(status);
+
+   if (m_3DContourNode.IsNotNull())
+      m_3DContourNode->SetVisibility(status, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
 }
diff --git a/Modules/QmitkExt/QmitkTransferFunctionGeneratorWidget.ui b/Modules/QmitkExt/QmitkTransferFunctionGeneratorWidget.ui
index 27bade05b2..ac793cfc1b 100644
--- a/Modules/QmitkExt/QmitkTransferFunctionGeneratorWidget.ui
+++ b/Modules/QmitkExt/QmitkTransferFunctionGeneratorWidget.ui
@@ -1,427 +1,422 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkTransferFunctionGeneratorWidget</class>
  <widget class="QWidget" name="QmitkTransferFunctionGeneratorWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>349</width>
     <height>316</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
     <horstretch>1</horstretch>
     <verstretch>1</verstretch>
    </sizepolicy>
   </property>
   <property name="maximumSize">
    <size>
     <width>16777215</width>
     <height>16777215</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QHBoxLayout" name="horizontalLayout_4">
    <property name="margin">
     <number>0</number>
    </property>
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="sizePolicy">
       <sizepolicy hsizetype="MinimumExpanding" vsizetype="Maximum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>0</height>
       </size>
      </property>
      <property name="maximumSize">
       <size>
        <width>16777215</width>
        <height>120</height>
       </size>
      </property>
      <property name="toolTip">
       <string/>
      </property>
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="m_PresetTab">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Presets</string>
       </attribute>
       <attribute name="toolTip">
        <string notr="true">Apply internal MITK transferfunction presets.
 Or save and load your own created transferfunctions in a folder in XML format.</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_3">
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>0</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="QComboBox" name="m_TransferFunctionComboBox">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="toolTip">
           <string>Choose one of generic MITK internal presets to apply on standard CT data or MR data.</string>
          </property>
          <property name="statusTip">
           <string>Load a MITK internal preset</string>
          </property>
          <property name="currentIndex">
           <number>-1</number>
          </property>
          <property name="iconSize">
           <size>
            <width>16</width>
            <height>16</height>
           </size>
          </property>
          <property name="duplicatesEnabled">
           <bool>false</bool>
          </property>
          <property name="frame">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_3">
          <item>
           <widget class="QLabel" name="m_InfoPreset">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>1</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>0</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>16777215</width>
              <height>25</height>
             </size>
            </property>
-           <property name="font">
-            <font>
-             <pointsize>7</pointsize>
-            </font>
-           </property>
            <property name="text">
             <string/>
            </property>
            <property name="textFormat">
             <enum>Qt::AutoText</enum>
            </property>
            <property name="alignment">
             <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
            </property>
            <property name="wordWrap">
             <bool>true</bool>
            </property>
            <property name="indent">
             <number>0</number>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="m_LoadPreset">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Maximum" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="maximumSize">
             <size>
              <width>64</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Load a transferfunction in xml-format from the filesystem.
 The load includes all transferfunctions: grayvalue, color and gradient.</string>
            </property>
            <property name="text">
             <string>Load</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="m_SavePreset">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Maximum" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="maximumSize">
             <size>
              <width>64</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Save a transferfunction in xml-format in the filesystem.
 The save includes all transferfunctions: grayvalue, color and gradient.</string>
            </property>
            <property name="text">
             <string>Save</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="m_ThresholdTab">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Threshold</string>
       </attribute>
       <attribute name="toolTip">
        <string>Generate a threshold transfer function interactively.
 Click on the cross and move the mouse.
 With a vertical move the function will be steeper or flatter.
 With a horizontal move the center of the function left or right.</string>
       </attribute>
       <layout class="QHBoxLayout" name="horizontalLayout">
        <item>
         <widget class="QmitkCrossWidget" name="m_CrossThreshold">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>48</width>
            <height>48</height>
           </size>
          </property>
          <property name="toolTip">
           <string>Click and hold left mouse button on the cross.
 Move the mouse to the top and the function will be flatter.
 Move the mouse to the  bottom and the function will be steeper.
 Move the mouse to the left and the function moves to the left.
 Move the mouse to the right and the function moves to the right. </string>
          </property>
          <property name="layoutDirection">
           <enum>Qt::LeftToRight</enum>
          </property>
          <property name="text">
           <string/>
          </property>
          <property name="pixmap">
           <pixmap resource="resources/QmitkResources.qrc">:/qmitk/cross.png</pixmap>
          </property>
          <property name="scaledContents">
           <bool>true</bool>
          </property>
          <property name="alignment">
           <set>Qt::AlignCenter</set>
          </property>
          <property name="indent">
           <number>-1</number>
          </property>
          <property name="textInteractionFlags">
           <set>Qt::NoTextInteraction</set>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="m_InfoThreshold">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>7</pointsize>
           </font>
          </property>
          <property name="text">
           <string>Click and hold left mouse button on the cross to interactively generate a threshold transferfunction</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="m_BellTab">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Bell</string>
       </attribute>
       <attribute name="toolTip">
        <string>Generate a bell transfer function interactively.
 Click on the cross and move the mouse.
 With a vertical move the bell will be narrower or wider.
 With a horizontal move the center of the bell moves to the left or right.</string>
       </attribute>
       <layout class="QHBoxLayout" name="horizontalLayout_2">
        <item>
         <widget class="QmitkCrossWidget" name="m_CrossLevelWindow">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>48</width>
            <height>48</height>
           </size>
          </property>
          <property name="toolTip">
           <string>Click and hold left mouse button on the cross.
 Move the mouse to the top and the bell will be wider.
 Move the mouse to the  bottom and the bell will be flattened.
 Move the mouse to the left and the center of the bell moves to the left.
 Move the mouse to the  right and the center of the bell moves to the right.</string>
          </property>
          <property name="text">
           <string/>
          </property>
          <property name="pixmap">
           <pixmap resource="resources/QmitkResources.qrc">:/qmitk/cross.png</pixmap>
          </property>
          <property name="scaledContents">
           <bool>true</bool>
          </property>
          <property name="alignment">
           <set>Qt::AlignCenter</set>
          </property>
          <property name="textInteractionFlags">
           <set>Qt::NoTextInteraction</set>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="m_InfoLevelWindow">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>7</pointsize>
           </font>
          </property>
          <property name="text">
           <string>Click and hold left mouse button on the cross to interactively generate a bell transferfunction</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkCrossWidget</class>
    <extends>QLabel</extends>
    <header location="global">QmitkCrossWidget.h</header>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="resources/QmitkResources.qrc"/>
  </resources>
  <connections/>
 </ui>
diff --git a/Modules/QmitkExt/QmitkTransferFunctionWidget.ui b/Modules/QmitkExt/QmitkTransferFunctionWidget.ui
index 408efa83da..dc252e2c8a 100755
--- a/Modules/QmitkExt/QmitkTransferFunctionWidget.ui
+++ b/Modules/QmitkExt/QmitkTransferFunctionWidget.ui
@@ -1,507 +1,482 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkTransferFunctionWidget</class>
  <widget class="QWidget" name="QmitkTransferFunctionWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>300</width>
     <height>542</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
     <horstretch>1</horstretch>
     <verstretch>1</verstretch>
    </sizepolicy>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="margin">
     <number>0</number>
    </property>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QmitkFloatingPointSpanSlider" name="m_RangeSlider">
        <property name="toolTip">
         <string>modify actual seen window by dragging left and right slider. </string>
        </property>
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="m_RangeSliderReset">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="maximumSize">
         <size>
          <width>48</width>
          <height>16777215</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Resets range to histogram minimum and maximum.</string>
        </property>
        <property name="text">
         <string>Reset</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QWidget" name="m_ScalarOpacityWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>3</verstretch>
       </sizepolicy>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <property name="margin">
        <number>0</number>
       </property>
       <item>
        <widget class="QmitkPiecewiseFunctionCanvas" name="m_ScalarOpacityFunctionCanvas" native="true">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
           <horstretch>0</horstretch>
           <verstretch>1</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>64</height>
          </size>
         </property>
         <property name="font">
          <font/>
         </property>
         <property name="toolTip">
          <string>Left-click to select a point or add a new point.
  Hold left mouse button to move selected point.
 Click right mouse button to delete a point.</string>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout">
         <item>
          <widget class="QLineEdit" name="m_XEditScalarOpacity">
           <property name="enabled">
            <bool>true</bool>
           </property>
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>48</width>
             <height>0</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>48</width>
             <height>16777215</height>
            </size>
           </property>
-          <property name="font">
-           <font>
-            <pointsize>7</pointsize>
-           </font>
-          </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string/>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="m_textLabelX">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="font">
            <font/>
           </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string>Grayvalue</string>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="m_textLabelY">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="font">
            <font/>
           </property>
           <property name="toolTip">
            <string>Edit y-coordinate (opacity) of currently selected point.</string>
           </property>
           <property name="text">
            <string>Opacity</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLineEdit" name="m_YEditScalarOpacity">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>48</width>
             <height>0</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>48</width>
             <height>16777215</height>
            </size>
           </property>
-          <property name="font">
-           <font>
-            <pointsize>7</pointsize>
-           </font>
-          </property>
           <property name="toolTip">
            <string>Edit y-coordinate (opacity) of currently selected point.</string>
           </property>
           <property name="text">
            <string/>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QWidget" name="m_ColorWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_3">
       <property name="margin">
        <number>0</number>
       </property>
       <item>
        <widget class="QmitkColorTransferFunctionCanvas" name="m_ColorTransferFunctionCanvas" native="true">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>1</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>48</height>
          </size>
         </property>
         <property name="font">
          <font/>
         </property>
         <property name="toolTip">
          <string>Left-click to select a point or add a new point.
  Hold left mouse button to move selected point.
 Click right mouse button to delete a point.
 Double-click left mouse button to change color of a point.</string>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout">
         <item>
          <widget class="QLineEdit" name="m_XEditColor">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>48</width>
             <height>0</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>48</width>
             <height>16777215</height>
            </size>
           </property>
-          <property name="font">
-           <font>
-            <pointsize>7</pointsize>
-           </font>
-          </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string/>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="m_textLabelX_3">
           <property name="font">
            <font/>
           </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string>Grayvalue</string>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QWidget" name="m_GradientOpacityWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>2</verstretch>
       </sizepolicy>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_4">
       <property name="margin">
        <number>0</number>
       </property>
       <item>
        <widget class="QmitkPiecewiseFunctionCanvas" name="m_GradientOpacityCanvas" native="true">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
           <horstretch>0</horstretch>
           <verstretch>1</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>64</height>
          </size>
         </property>
         <property name="font">
          <font/>
         </property>
         <property name="toolTip">
          <string>Left-click to select a point or add a new point.
  Hold left mouse button to move selected point.
 Click right mouse button to delete a point.</string>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout">
         <item>
          <widget class="QLineEdit" name="m_XEditGradientOpacity">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>48</width>
             <height>0</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>48</width>
             <height>16777215</height>
            </size>
           </property>
-          <property name="font">
-           <font>
-            <pointsize>7</pointsize>
-           </font>
-          </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string/>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="m_textLabelX_2">
           <property name="font">
            <font/>
           </property>
           <property name="toolTip">
            <string>Edit x-coordinate (grayvalue) of currently selected point.</string>
           </property>
           <property name="text">
            <string>Grayvalue</string>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="m_textLabelY_2">
           <property name="font">
            <font/>
           </property>
           <property name="toolTip">
            <string>Edit y-coordinate (opacity) of currently selected point.</string>
           </property>
           <property name="text">
            <string>Opacity</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLineEdit" name="m_YEditGradientOpacity">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>48</width>
             <height>0</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>48</width>
             <height>16777215</height>
            </size>
           </property>
-          <property name="font">
-           <font>
-            <pointsize>7</pointsize>
-           </font>
-          </property>
           <property name="toolTip">
            <string>Edit y-coordinate (opacity) of currently selected point.</string>
           </property>
           <property name="text">
            <string/>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
          </widget>
         </item>
        </layout>
       </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>0</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkPiecewiseFunctionCanvas</class>
    <extends>QWidget</extends>
    <header>QmitkPiecewiseFunctionCanvas.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkColorTransferFunctionCanvas</class>
    <extends>QWidget</extends>
    <header>QmitkColorTransferFunctionCanvas.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkFloatingPointSpanSlider</class>
    <extends>QSlider</extends>
    <header location="global">QmitkFloatingPointSpanSlider.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Modules/SceneSerialization/mitkSceneReaderV1.cpp b/Modules/SceneSerialization/mitkSceneReaderV1.cpp
index 1a9b31aa96..b785d71534 100644
--- a/Modules/SceneSerialization/mitkSceneReaderV1.cpp
+++ b/Modules/SceneSerialization/mitkSceneReaderV1.cpp
@@ -1,320 +1,327 @@
 /*===================================================================
 
 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 "mitkSceneReaderV1.h"
 #include "mitkSerializerMacros.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkBaseRenderer.h"
 #include "mitkPropertyListDeserializer.h"
 #include "mitkProgressBar.h"
 #include "Poco/Path.h"
 
 MITK_REGISTER_SERIALIZER(SceneReaderV1)
     
 bool mitk::SceneReaderV1::LoadScene( TiXmlDocument& document, const std::string& workingDirectory, DataStorage* storage )
 {
   assert(storage);
   bool error(false);
 
   // TODO prepare to detect errors (such as cycles) from wrongly written or edited xml files
 
   //Get number of elements to initialze progress bar
   unsigned int listSize = 0;
   for( TiXmlElement* element = document.FirstChildElement("node"); element != NULL; element = element->NextSiblingElement("node") )
   {
     ++listSize;
   }
 
   ProgressBar::GetInstance()->AddStepsToDo( listSize ); 
 
   // iterate all nodes
   // first level nodes should be <node> elements
   for( TiXmlElement* element = document.FirstChildElement("node"); element != NULL; element = element->NextSiblingElement("node") )
   {
     //   1. if there is a <data type="..." file="..."> element,
     //        - construct a name for the appropriate serializer
     //        - try to instantiate this serializer via itk object factory
     //        - if serializer could be created, use it to read the file into a BaseData object
     //        - if successful, call the new node's SetData(..)
     DataNode::Pointer node = LoadBaseDataFromDataTag( element->FirstChildElement("data"), workingDirectory, error );
 
     // create a node for the tag "data" and test if node was created
     // in case dataXmlElement is valid test whether it containts the "properties" child tag
     // and process further if and only if yes
     TiXmlElement *dataXmlElement = element->FirstChildElement("data");
     if( dataXmlElement && dataXmlElement->FirstChildElement("properties") )
     {
       TiXmlElement *baseDataElement = dataXmlElement->FirstChildElement("properties");
-      DecorateBaseDataWithProperties( node->GetData(), baseDataElement, workingDirectory);
+      if ( node->GetData() )
+      {
+        DecorateBaseDataWithProperties( node->GetData(), baseDataElement, workingDirectory);
+      }
+      else
+      {
+        MITK_WARN << "BaseData properties stored in scene file, but BaseData can't be read" << std::endl;
+      }
     }
 
     //   2. check child nodes
     const char* uida = element->Attribute("UID");
     std::string uid("");
 
     if (uida)
     {
       uid = uida;
       m_NodeForID[uid] = node.GetPointer();
       m_IDForNode[ node.GetPointer() ] = uid;
     }
     else
     {
       MITK_ERROR << "No UID found for current node. Node will have no parents.";
       error = true;
     }
 
     // remember node for later adding to DataStorage
     m_Nodes.insert( std::make_pair( node, std::list<std::string>() ) );
 
     //   3. if there are <source> elements, remember parent objects
     for( TiXmlElement* source = element->FirstChildElement("source"); source != NULL; source = source->NextSiblingElement("source") )
     {
       const char* sourceUID = source->Attribute("UID");
       if (sourceUID)
       {
         m_Nodes[node].push_back( std::string(sourceUID) );
       }
     }
 
 
     //   5. if there are <properties> nodes, 
     //        - instantiate the appropriate PropertyListDeSerializer
     //        - use them to construct PropertyList objects
     //        - add these properties to the node (if necessary, use renderwindow name)
     bool success = DecorateNodeWithProperties(node, element, workingDirectory);
     if (!success)
     {
       MITK_ERROR << "Could not load properties for node.";
       error = true;
     }
 
     ProgressBar::GetInstance()->Progress();
 
   } // end for all <node>
     
   // remove all unknown parent UIDs
   for (NodesAndParentsMapType::iterator nodesIter = m_Nodes.begin();
        nodesIter != m_Nodes.end();
        ++nodesIter)
   {
     for (std::list<std::string>::iterator parentsIter = nodesIter->second.begin();
          parentsIter != nodesIter->second.end();)
     {
       if (m_NodeForID.find( *parentsIter ) == m_NodeForID.end())
       {
         parentsIter = nodesIter->second.erase( parentsIter );
         MITK_WARN << "Found a DataNode with unknown parents. Will add it to DataStorage without any parent objects.";
         error = true;
       }
       else
       {
         ++parentsIter;
       }
     }
   }
 
   // repeat
   //   for all created nodes
   unsigned int lastMapSize(0);
   while ( lastMapSize != m_Nodes.size()) // this is to prevent infinite loops; each iteration must at least add one node to DataStorage
   {
     lastMapSize = m_Nodes.size();
 
     for (NodesAndParentsMapType::iterator nodesIter = m_Nodes.begin();
          nodesIter != m_Nodes.end();
          ++nodesIter)
     {
       bool addNow(true);
       // if any parent node is not yet in DataStorage, skip node for now and check later
       for (std::list<std::string>::iterator parentsIter = nodesIter->second.begin();
            parentsIter != nodesIter->second.end();
            ++parentsIter)
       {
         if ( !storage->Exists( m_NodeForID[ *parentsIter ] ) )
         {
           addNow = false;
           break;
         }
       }
       
       if (addNow)
       {
         DataStorage::SetOfObjects::Pointer parents = DataStorage::SetOfObjects::New();
         for (std::list<std::string>::iterator parentsIter = nodesIter->second.begin();
              parentsIter != nodesIter->second.end();
              ++parentsIter)
         {
           parents->push_back( m_NodeForID[ *parentsIter ] );
         }
    
         // if all parents are found in datastorage (or are unknown), add node to DataStorage
         storage->Add( nodesIter->first, parents );
 
         // remove this node from m_Nodes
         m_Nodes.erase( nodesIter );
 
         // break this for loop because iterators are probably invalid
         break;
       }
     }
   }
 
   // All nodes that are still in m_Nodes at this point are not part of a proper directed graph structure. We'll add such nodes without any parent information.
   for (NodesAndParentsMapType::iterator nodesIter = m_Nodes.begin();
        nodesIter != m_Nodes.end();
        ++nodesIter)
   {
     storage->Add( nodesIter->first );
     MITK_WARN << "Encountered node that is not part of a directed graph structure. Will be added to DataStorage without parents.";
     error = true;
   }
 
   return !error;
 }
 
 mitk::DataNode::Pointer mitk::SceneReaderV1::LoadBaseDataFromDataTag( TiXmlElement* dataElement, const std::string& workingDirectory, bool& error )
 {
   DataNode::Pointer node;
 
   if (dataElement) 
   {
     const char* filename( dataElement->Attribute("file") );
     if ( filename )
     {
       DataNodeFactory::Pointer factory = DataNodeFactory::New();
       factory->SetFileName( workingDirectory + Poco::Path::separator() + filename );
       
       try
       {
         factory->Update();
         node = factory->GetOutput();
       }
       catch (std::exception& e)
       {
         MITK_ERROR << "Error during attempt to read '" << filename << "'. Exception says: " << e.what();
         error = true;
       }
 
       if (node.IsNull())
       {
         MITK_ERROR << "Error during attempt to read '" << filename << "'. Factory returned NULL object.";
         error = true;
       }
     }
   }
 
   // in case there was no <data> element we create a new empty node (for appending a propertylist later)
   if (node.IsNull())
   {
     node = DataNode::New();
   }
 
   return node;
 }
 
 bool mitk::SceneReaderV1::DecorateNodeWithProperties(DataNode* node, TiXmlElement* nodeElement, const std::string& workingDirectory)
 {
   assert(node);
   assert(nodeElement);
   bool error(false);
 
   for( TiXmlElement* properties = nodeElement->FirstChildElement("properties"); properties != NULL; properties = properties->NextSiblingElement("properties") )
   {
     const char* propertiesfilea( properties->Attribute("file") );
     std::string propertiesfile( propertiesfilea ? propertiesfilea : "" );
     
     const char* renderwindowa( properties->Attribute("renderwindow") );
     std::string renderwindow( renderwindowa ? renderwindowa : "" );
 
     BaseRenderer* renderer = BaseRenderer::GetByName( renderwindow );
     if (renderer || renderwindow.empty())
     {
       PropertyList::Pointer propertyList = node->GetPropertyList(renderer); // DataNode implementation always returns a propertylist
       // clear all properties from node that might be set by DataNodeFactory during loading 
       propertyList->Clear();
 
       // use deserializer to construct new properties
       PropertyListDeserializer::Pointer deserializer = PropertyListDeserializer::New();
       
       deserializer->SetFilename(workingDirectory + Poco::Path::separator() + propertiesfile);
       bool success = deserializer->Deserialize();
       error |= !success;
       PropertyList::Pointer readProperties = deserializer->GetOutput();
 
       if (readProperties.IsNotNull())
       {
         propertyList->ConcatenatePropertyList( readProperties, true ); // true = replace
       }
       else
       {
         MITK_ERROR << "Property list reader did not return a property list. This is an implementation error. Please tell your developer.";
         error = true;
       }
     }
     else
     {
       MITK_ERROR << "Found properties for renderer " << renderwindow << " but there is no such renderer in current application. Ignoring those properties";
       error = true;
     }
   }
 
   return !error;
 }
 
 bool mitk::SceneReaderV1::DecorateBaseDataWithProperties(BaseData::Pointer data, TiXmlElement *baseDataNodeElem, const std::string &workingDir)
 {
   // check given variables, initialize error variable
   assert(baseDataNodeElem);
   bool error(false);
 
   // get the file name stored in the <properties ...> tag
   const char* baseDataPropertyFile( baseDataNodeElem->Attribute("file") );
   // check if the filename was found
   if(baseDataPropertyFile)
   {
     //PropertyList::Pointer dataPropList = data->GetPropertyList();
 
     PropertyListDeserializer::Pointer propertyDeserializer = PropertyListDeserializer::New();
 
     // initialize the property reader
     propertyDeserializer->SetFilename(workingDir + Poco::Path::separator() + baseDataPropertyFile);
     bool ioSuccess = propertyDeserializer->Deserialize();
     error = !ioSuccess;
 
     // get the output
     PropertyList::Pointer inProperties = propertyDeserializer->GetOutput();
 
     // store the read-in properties to the given node or throw error otherwise
     if( inProperties.IsNotNull() )
     {
       data->SetPropertyList( inProperties );
     }
     else
     {
       MITK_ERROR << "The property deserializer did not return a (valid) property list.";
       error = true;
     }
   }
   else
   {
     MITK_ERROR << "Function DecorateBaseDataWithProperties(...) called with false TiXmlElement. \n \t ->Given element does not contain a 'file' attribute. \n";
     error = true;
   }
 
   return !error;
 }
 
diff --git a/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp b/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp
index 9a42bac728..3556014474 100644
--- a/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp
+++ b/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp
@@ -1,246 +1,252 @@
 /*===================================================================
 
 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 "mitkSurfaceInterpolationController.h"
 #include "mitkMemoryUtilities.h"
 
 mitk::SurfaceInterpolationController::SurfaceInterpolationController()
 : m_CurrentContourListID (0)
 {
   m_ReduceFilter = ReduceContourSetFilter::New();
   m_NormalsFilter = ComputeContourSetNormalsFilter::New();
   m_InterpolateSurfaceFilter = CreateDistanceImageFromSurfaceFilter::New();
 
-  m_ReduceFilter->SetUseProgressBar(true);
-  m_NormalsFilter->SetUseProgressBar(true);
-  m_InterpolateSurfaceFilter->SetUseProgressBar(true);
+  m_ReduceFilter->SetUseProgressBar(false);
+  m_NormalsFilter->SetUseProgressBar(false);
+  m_InterpolateSurfaceFilter->SetUseProgressBar(false);
 
   m_Contours = Surface::New();
 
   m_PolyData = vtkSmartPointer<vtkPolyData>::New();
   m_PolyData->SetPoints(vtkPoints::New());
 
   m_InterpolationResult = 0;
   m_CurrentNumberOfReducedContours = 0;
 }
 
 mitk::SurfaceInterpolationController::~SurfaceInterpolationController()
 {
   for (unsigned int i = 0; i < m_ListOfContourLists.size(); ++i)
   {
       for (unsigned int j = 0; j < m_ListOfContourLists.at(i).size(); ++j)
       {
           delete(m_ListOfContourLists.at(i).at(j).position);
       }
   }
 }
 
 mitk::SurfaceInterpolationController* mitk::SurfaceInterpolationController::GetInstance()
 {
   static mitk::SurfaceInterpolationController* m_Instance;
 
   if ( m_Instance == 0)
   {
     m_Instance = new SurfaceInterpolationController();
   }
 
   return m_Instance;
 }
 
 void mitk::SurfaceInterpolationController::AddNewContour (mitk::Surface::Pointer newContour ,RestorePlanePositionOperation* op)
 {
   AffineTransform3D::Pointer transform = AffineTransform3D::New();
   transform = op->GetTransform();
 
   mitk::Vector3D direction = op->GetDirectionVector();
   int pos (-1);
 
   for (unsigned int i = 0; i < m_ListOfContourLists.at(m_CurrentContourListID).size(); i++)
   {
       itk::Matrix<float> diffM = transform->GetMatrix()-m_ListOfContourLists.at(m_CurrentContourListID).at(i).position->GetTransform()->GetMatrix();
       bool isSameMatrix(true);
       for (unsigned int j = 0; j < 3; j++)
       {
         if (fabs(diffM[j][0]) > 0.0001 && fabs(diffM[j][1]) > 0.0001 && fabs(diffM[j][2]) > 0.0001)
         {
           isSameMatrix = false;
           break;
         }
       }
       itk::Vector<float> diffV = m_ListOfContourLists.at(m_CurrentContourListID).at(i).position->GetTransform()->GetOffset()-transform->GetOffset();
       if ( isSameMatrix && m_ListOfContourLists.at(m_CurrentContourListID).at(i).position->GetPos() == op->GetPos() && (fabs(diffV[0]) < 0.0001 && fabs(diffV[1]) < 0.0001 && fabs(diffV[2]) < 0.0001) )
       {
         pos = i;
         break;
       }
     
   }
 
   if (pos == -1)
   {
     //MITK_INFO<<"New Contour";
     mitk::RestorePlanePositionOperation* newOp = new mitk::RestorePlanePositionOperation (OpRESTOREPLANEPOSITION, op->GetWidth(), 
       op->GetHeight(), op->GetSpacing(), op->GetPos(), direction, transform);
     ContourPositionPair newData;
     newData.contour = newContour;
     newData.position = newOp;
 
     m_ReduceFilter->SetInput(m_ListOfContourLists.at(m_CurrentContourListID).size(), newContour);
     m_ListOfContourLists.at(m_CurrentContourListID).push_back(newData);
   }
   else
   {
     //MITK_INFO<<"Modified Contour";
     m_ListOfContourLists.at(m_CurrentContourListID).at(pos).contour = newContour;
     m_ReduceFilter->SetInput(pos, newContour);
   }
 
   m_ReduceFilter->Update();
   m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
 
   for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
   {
     m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
     m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
   }
 
   this->Modified();
 }
 
 void mitk::SurfaceInterpolationController::Interpolate()
 {
   if (m_CurrentNumberOfReducedContours< 2)
     return;
 
   //Setting up progress bar
-  mitk::ProgressBar::GetInstance()->AddStepsToDo(8);
+   /*
+    * Removed due to bug 12441. ProgressBar messes around with Qt event queue which is fatal for segmentation
+    */
+  //mitk::ProgressBar::GetInstance()->AddStepsToDo(8);
 
   m_InterpolateSurfaceFilter->Update();
 
   Image::Pointer distanceImage = m_InterpolateSurfaceFilter->GetOutput();
 
   vtkSmartPointer<vtkMarchingCubes> mcFilter = vtkMarchingCubes::New();
   mcFilter->SetInput(distanceImage->GetVtkImageData());
   mcFilter->SetValue(0,0);
   mcFilter->Update();
 
   m_InterpolationResult = 0;
   m_InterpolationResult = mitk::Surface::New();
   m_InterpolationResult->SetVtkPolyData(mcFilter->GetOutput());
   m_InterpolationResult->GetGeometry()->SetOrigin(distanceImage->GetGeometry()->GetOrigin());
 
   vtkSmartPointer<vtkAppendPolyData> polyDataAppender = vtkSmartPointer<vtkAppendPolyData>::New();
   for (unsigned int i = 0; i < m_ReduceFilter->GetNumberOfOutputs(); i++)
   {
     polyDataAppender->AddInput(m_ReduceFilter->GetOutput(i)->GetVtkPolyData());
   }
   polyDataAppender->Update();
   m_Contours->SetVtkPolyData(polyDataAppender->GetOutput());
 
   //Last progress step
-  mitk::ProgressBar::GetInstance()->Progress(8);
+  /*
+   * Removed due to bug 12441. ProgressBar messes around with Qt event queue which is fatal for segmentation
+   */
+  //mitk::ProgressBar::GetInstance()->Progress(8);
 
   m_InterpolationResult->DisconnectPipeline();
 }
 
 mitk::Surface::Pointer mitk::SurfaceInterpolationController::GetInterpolationResult()
 {
     return m_InterpolationResult;
 }
 
 mitk::Surface* mitk::SurfaceInterpolationController::GetContoursAsSurface()
 {
   return m_Contours;
 }
 
 void mitk::SurfaceInterpolationController::SetDataStorage(DataStorage &ds)
 {
   m_DataStorage = &ds;
 }
 
 unsigned int mitk::SurfaceInterpolationController::CreateNewContourList()
 {
   unsigned int newID =  m_ListOfContourLists.size();
   ContourPositionPairList newList;
   m_ListOfContourLists.push_back(newList);
   this->SetCurrentListID(newID);
   m_InterpolationResult = 0;
   return m_CurrentContourListID;
 }
 
 void mitk::SurfaceInterpolationController::SetCurrentListID ( unsigned int ID )
 {
   if (ID == m_CurrentContourListID )
     return;
 
   m_CurrentContourListID = ID;
 
   m_ReduceFilter->Reset();
   m_NormalsFilter->Reset();
   m_InterpolateSurfaceFilter->Reset();
   
   for (unsigned int i = 0; i < m_ListOfContourLists.at(m_CurrentContourListID).size(); i++)
   {
     m_ReduceFilter->SetInput(i, m_ListOfContourLists.at(m_CurrentContourListID).at(i).contour);
 //    m_NormalsFilter->SetInput(i,m_ReduceFilter->GetOutput(i));
 //    m_InterpolateSurfaceFilter->SetInput(i,m_NormalsFilter->GetOutput(i));
   }
 
   m_ReduceFilter->Update();
 
   m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
 
   for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
   {
     m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
     m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
   }
 }
 
 void mitk::SurfaceInterpolationController::SetMinSpacing(double minSpacing)
 {
   m_ReduceFilter->SetMinSpacing(minSpacing);
 }
 
 void mitk::SurfaceInterpolationController::SetMaxSpacing(double maxSpacing)
 {
   m_ReduceFilter->SetMaxSpacing(maxSpacing);
   m_NormalsFilter->SetMaxSpacing(maxSpacing);
 }
 
 void mitk::SurfaceInterpolationController::SetDistanceImageVolume(unsigned int distImgVolume)
 {
   m_InterpolateSurfaceFilter->SetDistanceImageVolume(distImgVolume);
 }
 
 void mitk::SurfaceInterpolationController::SetWorkingImage(Image* workingImage)
 {
   m_NormalsFilter->SetSegmentationBinaryImage(workingImage);
 }
 
 mitk::Image* mitk::SurfaceInterpolationController::GetImage()
 {
   return m_InterpolateSurfaceFilter->GetOutput();
 }
 
 double mitk::SurfaceInterpolationController::EstimatePortionOfNeededMemory()
 {
   double numberOfPointsAfterReduction = m_ReduceFilter->GetNumberOfPointsAfterReduction()*3;
   double sizeOfPoints = pow(numberOfPointsAfterReduction,2)*sizeof(double);
   double totalMem = mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
   double percentage = sizeOfPoints/totalMem;
   return percentage;
 }
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index b54147f8cd..9e8bc701a5 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,361 +1,372 @@
 /*===================================================================
 
 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 "mitkSegTool2D.h"
 #include "mitkToolManager.h"
 
 #include "mitkDataStorage.h"
 #include "mitkBaseRenderer.h"
 
 #include "mitkPlaneGeometry.h"
 
 #include "mitkExtractImageFilter.h"
 #include "mitkExtractDirectedPlaneImageFilter.h"
 
 //Include of the new ImageExtractor
 #include "mitkExtractDirectedPlaneImageFilterNew.h"
 #include "mitkPlanarCircle.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkOverwriteDirectedPlaneImageFilter.h"
 
 #include "mitkGetModuleContext.h"
 
 //Includes for 3DSurfaceInterpolation
 #include "mitkImageToContourFilter.h"
 #include "mitkSurfaceInterpolationController.h"
 
 //includes for resling and overwriting
 #include <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 #include <vtkSmartPointer.h>
 #include <vtkImageData.h>
 
 #include <mitkDiffSliceOperationApplier.h>
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 
 #define ROUND(a)     ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 mitk::SegTool2D::SegTool2D(const char* type)
 :Tool(type),
  m_LastEventSender(NULL),
  m_LastEventSlice(0),
  m_Contourmarkername ("Position"),
  m_ShowMarkerNodes (true),
  m_3DInterpolationEnabled(true)
 {
 }
 
 mitk::SegTool2D::~SegTool2D()
 {
 }
 
 float mitk::SegTool2D::CanHandleEvent( StateEvent const *stateEvent) const
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return 0.0;
 
   if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D ) return 0.0; // we don't want anything but 2D
 
   //This are the mouse event that are used by the statemachine patterns for zooming and panning. This must be possible although a tool is activ
   if (stateEvent->GetId() == EIDRIGHTMOUSEBTN || stateEvent->GetId() == EIDMIDDLEMOUSEBTN || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDCTRL ||
       stateEvent->GetId() == EIDMIDDLEMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSERELEASE || stateEvent->GetId() == EIDRIGHTMOUSEBTNANDMOUSEMOVE ||
       stateEvent->GetId() == EIDMIDDLEMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNANDMOUSEMOVE || stateEvent->GetId() == EIDCTRLANDRIGHTMOUSEBTNRELEASE )
   {
     //Since the usual segmentation tools currently do not need right click interaction but the mitkDisplayVectorInteractor
     return 0.0;
   }
   else
   {
     return 1.0;
   }
 }
 
 
 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.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal0.Get_vnl_vector()) );
   imageNormal1.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal1.Get_vnl_vector()) );
   imageNormal2.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal2.Get_vnl_vector()) );
 
   double eps( 0.00001 );
   // axial
   if ( imageNormal2.GetNorm() <= eps )
   {
     affectedDimension = 2;
   }
   // sagittal
   else if ( imageNormal1.GetNorm() <= eps )
   {
     affectedDimension = 1;
   }
   // frontal
   else if ( imageNormal0.GetNorm() <= eps )
   {
     affectedDimension = 0;
   }
   else
   {
     affectedDimension = -1; // no idea
     return false;
   }
 
   // determine slice number in image
   Geometry3D* 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;
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PositionEvent* positionEvent, const Image* image)
 {
   if (!positionEvent) return NULL;
 
   assert( positionEvent->GetSender() ); // sure, right?
   unsigned int timeStep = positionEvent->GetSender()->GetTimeStep( image ); // get the timestep of the visible part (time-wise) of the image
 
   // first, we determine, which slice is affected
   const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
 
   if ( !image || !planeGeometry ) return NULL;
 
   //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->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
 
   extractor->Modified();
   extractor->Update();
 
   Image::Pointer slice = extractor->GetOutput();
 
   /*============= BEGIN undo feature block ========================*/
   //specify the undo operation with the non edited slice
   m_undoOperation = new DiffSliceOperation(const_cast<mitk::Image*>(image), extractor->GetVtkOutput(), slice->GetGeometry(), timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
   /*============= END undo feature block ========================*/
 
   return slice;
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const PositionEvent* positionEvent)
 {
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   if ( !workingNode ) return NULL;
 
   Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
   if ( !workingImage ) return NULL;
 
   return GetAffectedImageSliceAs2DImage( positionEvent, workingImage );
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const PositionEvent* positionEvent)
 {
   DataNode* referenceNode( m_ToolManager->GetReferenceData(0) );
   if ( !referenceNode ) return NULL;
 
   Image* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
   if ( !referenceImage ) return NULL;
 
   return GetAffectedImageSliceAs2DImage( positionEvent, referenceImage );
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResult (const PositionEvent* positionEvent, Image* slice)
 {
   const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
 
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   Image* image = dynamic_cast<Image*>(workingNode->GetData());
 
   unsigned int timeStep = positionEvent->GetSender()->GetTimeStep( image );
 
     //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'
   reslice->SetInputSlice(slice->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( image );
   extractor->SetTimeStep( timeStep );
   extractor->SetWorldGeometry( planeGeometry );
   extractor->SetVtkOutputRequest(true);
   extractor->SetResliceTransformByGeometry( image->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
 
   extractor->Modified();
   extractor->Update();
 
   //the image was modified within the pipeline, but not marked so
   image->Modified();
 
   /*============= BEGIN undo feature block ========================*/
   //specify the undo operation with the edited slice
   m_doOperation = new DiffSliceOperation(image, extractor->GetVtkOutput(),slice->GetGeometry(), timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
   
   //create an operation event for the undo stack
   OperationEvent* undoStackItem = new OperationEvent( DiffSliceOperationApplier::GetInstance(), m_doOperation, m_undoOperation, "Segmentation" );
   
   //add it to the undo controller
   UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
 
   //clear the pointers as the operation are stored in the undocontroller and also deleted from there
   m_undoOperation = NULL;
   m_doOperation = NULL;
   /*============= END undo feature block ========================*/
   
   slice->DisconnectPipeline();
   ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
   contourExtractor->SetInput(slice);
   contourExtractor->Update();
   mitk::Surface::Pointer contour = contourExtractor->GetOutput();
 
   if (m_3DInterpolationEnabled && contour->GetVtkPolyData()->GetNumberOfPoints() > 0 )
   {
     unsigned int pos = this->AddContourmarker(positionEvent);
     mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
     PlanePositionManagerService* service = dynamic_cast<PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
     mitk::SurfaceInterpolationController::GetInstance()->AddNewContour( contour, service->GetPlanePosition(pos));
     contour->DisconnectPipeline();
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::SegTool2D::SetShowMarkerNodes(bool status)
 {
     m_ShowMarkerNodes = status;
 }
 
 void mitk::SegTool2D::SetEnable3DInterpolation(bool enabled)
 {
   m_3DInterpolationEnabled = enabled;
 }
 
 unsigned int mitk::SegTool2D::AddContourmarker ( const PositionEvent* positionEvent )
 {
   const mitk::Geometry2D* plane = dynamic_cast<const Geometry2D*> (dynamic_cast< const mitk::SlicedGeometry3D*>(
     positionEvent->GetSender()->GetSliceNavigationController()->GetCurrentGeometry3D())->GetGeometry2D(0));
 
   mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
   PlanePositionManagerService* service = dynamic_cast<PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
   unsigned int size = service->GetNumberOfPlanePositions();
   unsigned int id = service->AddNewPlanePosition(plane, positionEvent->GetSender()->GetSliceNavigationController()->GetSlice()->GetPos());
 
   mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
+  mitk::Point2D p1;
+  plane->Map(plane->GetCenter(), p1);
+  mitk::Point2D p2 = p1;
+  p2[0] -= plane->GetSpacing()[0];
+  p2[1] -= plane->GetSpacing()[1];
+  contourMarker->PlaceFigure( p1 );
+  contourMarker->SetCurrentControlPoint( p1 );
   contourMarker->SetGeometry2D( const_cast<Geometry2D*>(plane));
 
   std::stringstream markerStream;
   mitk::DataNode* workingNode (m_ToolManager->GetWorkingData(0));
 
   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, positionEvent->GetSender() );
   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 (plane)
   {
 
     if ( id ==  size )
     {
       m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
     else
     {
         mitk::NodePredicateProperty::Pointer isMarker = mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
 
         mitk::DataStorage::SetOfObjects::ConstPointer markers = m_ToolManager->GetDataStorage()->GetDerivations(workingNode,isMarker);
 
         for ( mitk::DataStorage::SetOfObjects::const_iterator 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;
             }
         }
         m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
   }
   return id;
 }
 
 void mitk::SegTool2D::InteractiveSegmentationBugMessage( const std::string& message )
 {
   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
     << " http://bugs.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;
 }
 
diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/documentation/UserManual/QmitkBasicImageProcessing.dox b/Plugins/org.mitk.gui.qt.basicimageprocessing/documentation/UserManual/QmitkBasicImageProcessing.dox
index 6fd28a3e43..58326c13d8 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/documentation/UserManual/QmitkBasicImageProcessing.dox
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/documentation/UserManual/QmitkBasicImageProcessing.dox
@@ -1,132 +1,132 @@
 /**
-\page org_mitk_views_basicimageprocessing The Basic Image Processing Module
+\page org_mitk_views_basicimageprocessing The Basic Image Processing Plugin
 
-\image html ImageProcessing_48.png "Icon of the Module"
+\image html ImageProcessing_48.png "Icon of the Plugin"
 
 \section QmitkBasicImageProcessingUserManualSummary Summary
 
-This module provides an easy interface to fundamental image preprocessing and enhancement filters.
+This view provides an easy interface to fundamental image preprocessing and enhancement filters.
 It offers filter operations on 3D and 4D images in the areas of noise suppression, morphological operations, edge detection and image arithmetics, 
 as well as image inversion and downsampling.
 
 Please see \ref QmitkBasicImageProcessingUserManualDetails for more detailed information on usage and supported filters.
-If you encounter problems using the module, please have a look at the \ref QmitkBasicImageProcessingUserManualTrouble page.
+If you encounter problems using the view, please have a look at the \ref QmitkBasicImageProcessingUserManualTrouble page.
 
 \section QmitkBasicImageProcessingUserManualDetails Details
 
 Manual sections:
 
 - \ref QmitkBasicImageProcessingUserManualOverview 
 - \ref QmitkBasicImageProcessingUserManualFilters 
 - \ref QmitkBasicImageProcessingUserManualUsage
 - \ref QmitkBasicImageProcessingUserManualTrouble
 
 \section QmitkBasicImageProcessingUserManualOverview Overview
 
-This module provides an easy interface to fundamental image preprocessing and image enhancement filters.
+This view provides an easy interface to fundamental image preprocessing and image enhancement filters.
 It offers a variety of filter operations in the areas of noise suppression, morphological operations, edge detection and image arithmetics.
-At the moment, the module can be used with all 3D and 4D image types loadable by MITK. 2D image support will be added in the future. 
+At the moment, the view can be used with all 3D and 4D image types loadable by MITK. 2D image support will be added in the future. 
 All filters are encapsulated from the Insight Segmentation and Registration Toolkit (ITK, www.itk.org). 
 
-\image html BIP_Overview.png "MITK with the Basic Image Processing module"
+\image html BIP_Overview.png "MITK with the Basic Image Processing view"
 
-This document will tell you how to use this module, but it is assumed that you already know how to use MITK in general.
+This document will tell you how to use this view, but it is assumed that you already know how to use MITK in general.
 
 \section QmitkBasicImageProcessingUserManualFilters Filters
 
 This section will not describe the fundamental functioning of the single filters in detail, though.
 If you want to know more about a single filter, please have a look at http://www.itk.org/Doxygen316/html/classes.html 
 or in any good digital image processing book. For total denoising filter, please see Tony F. Chan et al., "The digital TV filter and nonlinear denoising".
 
 Available filters are:
 
 <H2>\a Single image operations</H2>
 
 <ul>
 <li><b>Noise Suppression</b></li>
   <ul>
   <li> Gaussian Denoising</li>
   <li> Median Filtering</li>
   <li> Total Variation Denoising</li>
   </ul>
   
 <li><b>Morphological Operations</b></li>
   <ul>
   <li> Dilation</li>
   <li> Erosion</li>
   <li> Opening</li>
   <li> Closing</li>
   </ul>
   
 <li><b>%Edge Detection</b></li>
   <ul>
   <li> Gradient Image</li>
   <li> Laplacian Operator (Second Derivative)</li>
   <li> Sobel Operator</li>
   </ul>
   
 <li><b>Misc</b></li>
   <ul>
   <li> Threshold </li>
   <li> Image Inversion</li>
   <li> Downsampling (isotropic)</li>  
   </ul>
 </ul>
   
 <H2>\a Dual image operations</H2>
 
 <ul>  
 <li><b>Image Arithmetics</b></li>
   <ul>
   <li> Add two images</li>
   <li> Subtract two images</li>
   <li> Multiply two images</li>
   <li> Divide two images</li>
   </ul>
   
   <li><b>Binary Operations</b></li>
   <ul>
   <li> Logical AND</li>
   <li> Logical OR</li>
   <li> Logical XOR</li>
   </ul>
 </ul> 
 
 \section QmitkBasicImageProcessingUserManualUsage Usage
 
 All you have to do to use a filter is to:
 <ul>
 <li> Load an image into MITK</li>
 <li> Select it in data manager
 <li> Select which filter you want to use via the drop down list</li>
 <li> Press the execute button</li>
 </ul>
 A busy cursor appeares; when it vanishes, the operation is completed. Your filtered image is displayed and selected for further processing.
 (If the  checkbox "Hide original image" is not selected, you will maybe not see the filter result imideately, 
 because your filtered image is possibly hidden by the original.)
 
 For two image operations, please make sure that the correct second image is selected in the drop down menu, and the image order is correct.
 For sure, image order only plays a role for image subtraction and division. These are conducted (Image1 - Image2) or (Image1 / Image2), respectively.
 
 Please Note: When you select a 4D image, you can select the time step for the filter to work on via the time slider at the top of the GUI.
 The 3D image at this time step is extracted and processed. The result will also be a 3D image.
 This means, a true 4D filtering is not yet supported.
 
 \section QmitkBasicImageProcessingUserManualTrouble Troubleshooting
 
 <B>I get an error when using a filter on a 2D image.</B><BR>
 2D images are not yet supported...
 
 <B>I use a filter on a 4D image, and the output is 3D.</B><BR>
 When you select a 4D image, you can select the time step for the filter to work on via the time slider at the top of the GUI.
 The 3D image at this time step is extracted and processed. The result will also be a 3D image.
 This means, a true 4D filtering is not supported by now.
 
 <B>A filter crashes during execution.</B><BR>
 Maybe your image is too large. Some filter operations, like derivatives, take a lot of memory.
 Try downsampling your image first. 
 
 <B>All other problems.</B><BR>
 Please report to the MITK mailing list.
 See http://www.mitk.org/wiki/Mailinglist on how to do this.
 */
diff --git a/Plugins/org.mitk.gui.qt.datamanager/plugin.xml b/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
index 90b564e87d..da42228672 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
@@ -1,45 +1,40 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <plugin>
   <extension point="org.blueberry.ui.views">
     <category 
       id="org.mitk.views.general" 
       name="MITK General"/> 
     <view 
       id="org.mitk.views.datamanager" 
       name="Datamanager" 
       category="org.mitk.views.general"
       icon="resources/DataManager_48.png"
       class="QmitkDataManagerView" />
   </extension>
   
   <extension point="org.blueberry.ui.views">
     <view 
       id="org.mitk.views.propertylistview" 
       name="Property List" 
       icon="resources/propertylist.png"
       class="QmitkPropertyListView" />
-    <view
-      id="org.mitk.views.propertytreeview"
-      name="Properties"
-      icon="resources/propertylist.png"
-      class="QmitkPropertyTreeView" />
   </extension>
 
   <extension point="org.blueberry.ui.preferencePages">
     <page id="org.mitk.gui.qt.application.DataManagerPreferencePage" name="DataManager" class="QmitkDataManagerPreferencePage">
       <keywordreference id="org.mitk.gui.qt.application.DataManagerPreferencePageKeywords"></keywordreference>
     </page>
     <page id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPage" name="Hotkeys" class="QmitkDataManagerHotkeysPrefPage" category="org.mitk.gui.qt.application.DataManagerPreferencePage">
       <keywordreference id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPageKeywords"></keywordreference>
     </page>
   </extension>
 
   <extension point="org.blueberry.ui.keywords">
     <keyword id="org.mitk.gui.qt.application.DataManagerPreferencePageKeywords" label="data manager"></keyword>
     <keyword id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPageKeywords" label="data manager hotkeys"></keyword>
   </extension>
   
   <extension-point id="contextMenuActions" name="Context menu actions"/>
   
 </plugin>
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/internal/mitkPluginActivator.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/internal/mitkPluginActivator.cpp
index 15bf6d8490..e774ec0ae8 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/internal/mitkPluginActivator.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/internal/mitkPluginActivator.cpp
@@ -1,44 +1,42 @@
 /*===================================================================
 
 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 "mitkPluginActivator.h"
 
 #include <QtPlugin>
 
 #include "QmitkPropertyListView.h"
-#include "QmitkPropertyTreeView.h"
 #include "../QmitkDataManagerView.h"
 #include "../QmitkDataManagerPreferencePage.h"
 #include "../QmitkDataManagerHotkeysPrefPage.h"
 
 namespace mitk {
 
 void PluginActivator::start(ctkPluginContext* context)
 {
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDataManagerView, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkPropertyListView, context)
-  BERRY_REGISTER_EXTENSION_CLASS(QmitkPropertyTreeView, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDataManagerPreferencePage, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDataManagerHotkeysPrefPage, context)
 }
 
 void PluginActivator::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 }
 
 }
 
 Q_EXPORT_PLUGIN2(org_mitk_gui_qt_datamanager, mitk::PluginActivator)
diff --git a/Plugins/org.mitk.gui.qt.dicom/documentation/Manual/Manual.dox b/Plugins/org.mitk.gui.qt.dicom/documentation/Manual/Manual.dox
deleted file mode 100644
index 56f79ae50a..0000000000
--- a/Plugins/org.mitk.gui.qt.dicom/documentation/Manual/Manual.dox
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
-\page org_mitk_gui_qt_dicom Dicom
-
-\image html icon.png "Icon of Dicom"
-
-Available sections:
-  - \ref org_mitk_gui_qt_dicomOverview
-
-\section org_mitk_gui_qt_dicomOverview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
-
diff --git a/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/Manual.dox
new file mode 100644
index 0000000000..72959c3280
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/Manual.dox
@@ -0,0 +1,16 @@
+/**
+\page org_mitk_gui_qt_dicom The Dicom Plugin
+
+\image html icon.png "Icon of Dicom"
+
+\warning This plugin is experimental and not all of the described features behave as expected.
+
+Available sections:
+  - \ref org_mitk_gui_qt_dicomOverview
+
+\section org_mitk_gui_qt_dicomOverview Overview
+
+The DICOM editor is an experimental editor which allows for loading of DICOM images as well as server communication. It features a highly experimental query/retrieve (you need to configure your PACS correspondingly) as well as a DICOM browser. The DICOM browser allows you to navigate the DICOM folder/cd depending on its metadata (patient/study/series) and import selected series for viewing in your MITK based application.
+
+It is based on the <a href="http://www.commontk.org/index.php/Documentation/Dicom_Overview">commonTK (CTK) DICOM funcionality</a>.
+*/
diff --git a/Plugins/org.mitk.gui.qt.dicom/documentation/Manual/icon.png b/Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/icon.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.dicom/documentation/Manual/icon.png
rename to Plugins/org.mitk.gui.qt.dicom/documentation/UserManual/icon.png
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui
index ec8d717b6f..d7954fbf11 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/QmitkDicomEditorControls.ui
@@ -1,264 +1,274 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkDicomEditorControls</class>
  <widget class="QWidget" name="QmitkDicomEditorControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>752</width>
     <height>696</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="acceptDrops">
    <bool>false</bool>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_8">
    <item>
     <widget class="QFrame" name="frame">
      <property name="frameShape">
       <enum>QFrame::StyledPanel</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Raised</enum>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
+      <item>
+       <widget class="QLabel" name="label">
+        <property name="text">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;WARNING: this plugin is highly experimental!&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
+        <property name="textFormat">
+         <enum>Qt::AutoText</enum>
+        </property>
+       </widget>
+      </item>
       <item>
        <widget class="QFrame" name="frame_3">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Plain</enum>
         </property>
         <property name="lineWidth">
          <number>0</number>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout_6">
          <property name="margin">
           <number>0</number>
          </property>
          <item>
           <widget class="QPushButton" name="LocalStorageButton">
            <property name="toolTip">
             <string>Local storage you can find your dicom data here.</string>
            </property>
            <property name="text">
             <string>Local Storage</string>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="checkable">
             <bool>false</bool>
            </property>
            <property name="flat">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="CDButton">
            <property name="toolTip">
             <string>Imports dicom data to your local storage from CD.</string>
            </property>
            <property name="text">
             <string>Import CD</string>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="flat">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="FolderButton">
            <property name="toolTip">
             <string>Imports dicom data to your local storage from a folder.</string>
            </property>
            <property name="text">
             <string>Import Folder</string>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="flat">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="QueryRetrieveButton">
            <property name="toolTip">
             <string>Query dicom data from a PACS and retrieve it to your system.</string>
            </property>
            <property name="text">
             <string>Query Retrieve</string>
            </property>
            <property name="iconSize">
             <size>
              <width>32</width>
              <height>32</height>
             </size>
            </property>
            <property name="flat">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_5">
            <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>
        </widget>
       </item>
       <item>
        <widget class="QStackedWidget" name="stackedWidget">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="currentIndex">
          <number>0</number>
         </property>
         <widget class="QWidget" name="page">
          <layout class="QVBoxLayout" name="verticalLayout_3">
           <item>
            <widget class="QmitkDicomLocalStorageWidget" name="internalDataWidget" native="true"/>
           </item>
          </layout>
         </widget>
         <widget class="QWidget" name="importWidgetPage">
          <layout class="QVBoxLayout" name="verticalLayout_9">
           <item>
            <widget class="QmitkDicomExternalDataWidget" name="externalDataWidget" native="true"/>
           </item>
          </layout>
         </widget>
         <widget class="QWidget" name="queryRetrieveWidgetPage">
          <layout class="QVBoxLayout" name="verticalLayout_12">
           <item>
            <widget class="ctkDICOMQueryRetrieveWidget" name="m_ctkDICOMQueryRetrieveWidget" native="true"/>
           </item>
          </layout>
         </widget>
        </widget>
       </item>
       <item>
        <widget class="QFrame" name="frame_2">
         <property name="frameShape">
          <enum>QFrame::StyledPanel</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <property name="spacing">
           <number>0</number>
          </property>
          <property name="margin">
           <number>0</number>
          </property>
          <item>
           <spacer name="horizontalSpacer_2">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeType">
             <enum>QSizePolicy::Minimum</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>4</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QLabel" name="StoreSCPStatusLabel">
            <property name="text">
             <string/>
            </property>
            <property name="textFormat">
             <enum>Qt::RichText</enum>
            </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>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>ctkDICOMQueryRetrieveWidget</class>
    <extends>QWidget</extends>
    <header>ctkDICOMQueryRetrieveWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDicomLocalStorageWidget</class>
    <extends>QWidget</extends>
    <header>Qmitk/QmitkDicomLocalStorageWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDicomExternalDataWidget</class>
    <extends>QWidget</extends>
    <header>Qmitk/QmitkDicomExternalDataWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
  <slots>
   <slot>OnChangePage(int)</slot>
  </slots>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkBrainNetworkAnalysis.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkBrainNetworkAnalysis.dox
index bc4a10931b..5a754a6cc2 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkBrainNetworkAnalysis.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkBrainNetworkAnalysis.dox
@@ -1,69 +1,69 @@
 /**
-\page org_mitk_views_brainnetworkanalysis The Brain Network Analysis Module
+\page org_mitk_views_brainnetworkanalysis The Brain Network Analysis View
 
-\image html QmitkBrainNetworkAnalysisViewIcon_64.png "Icon of the Module"
+\image html QmitkBrainNetworkAnalysisViewIcon_64.png "Icon of the View"
 
 \section QmitkBrainNetworkAnalysisUserManualSummary Summary
 
-This module can be used to create a network from a parcellation and a fiber image as well as to calculate and display network statistics.
+This view can be used to create a network from a parcellation and a fiber image as well as to calculate and display network statistics.
 
-This document will tell you how to use this module, but it is assumed that you already know how to use MITK in general.
+This document will tell you how to use this view, but it is assumed that you already know how to use MITK in general.
 
 Please see \ref QmitkBrainNetworkAnalysisUserManualDetails for more detailed information on usage and supported filters.
-If you encounter problems using the module, please have a look at the \ref QmitkBrainNetworkAnalysisUserManualTrouble page.
+If you encounter problems using the view, please have a look at the \ref QmitkBrainNetworkAnalysisUserManualTrouble page.
 
 \section QmitkBrainNetworkAnalysisUserManualDetails Details
 
 Manual sections:
 
 - \ref QmitkBrainNetworkAnalysisUserManualOverview 
 - \ref QmitkBrainNetworkAnalysisUserManualUsage
 - \ref QmitkBrainNetworkAnalysisUserManualTrouble
 
 \section QmitkBrainNetworkAnalysisUserManualOverview Overview
 
-This module is currently under heavy development and as such the interface as well as the capabilities are likely to change significantly between different versions.
+This view is currently under heavy development and as such the interface as well as the capabilities are likely to change significantly between different versions.
 
 This documentation describes the features of this current version.
 
 \image html QmitkBrainNetworkAnalysisInterface.png "The interface"
 
 \section QmitkBrainNetworkAnalysisUserManualUsage Usage
 
-To create a network select first a parcellation of the brain (e.g. as provided by <a href="http://surfer.nmr.mgh.harvard.edu/">freesurfer</a>  ) by CTRL+Leftclick and secondly a fiber image ( as created using tractography module). Then click on the "Create Network" button.
+To create a network select first a parcellation of the brain (e.g. as provided by <a href="http://surfer.nmr.mgh.harvard.edu/">freesurfer</a>  ) by CTRL+Leftclick and secondly a fiber image ( as created using tractography view). Then click on the "Create Network" button.
 
 To calculate network statistics select a network in the datamanager. At this time the following statistics are calculated for the entire network:
 
 <ul>
   <li> The number of vertices in the network
   <li> The number of edges in the network
   <li> The number of edges which have the same vertex as beginning and end point
   <li> The average degree of the nodes in the network
   <li> The connection density the network (the number of edges divided by the number of possible edges)
   <li> The unweighted efficiency of the network ( 1 divided by average path length, this is zero for disconnected graphs)
   <li> The global clustering
 </ul>
 
 Furthermore some statistics are calculated on a per node basis and displayed as histograms:
 
 <ul>
   <li> The degree of each node
   <li> The (unweighted) betweenness centrality of each node
   <li> The spread of shortest paths between each pair of nodes (For disconnected graphs the shortest paths with infinite length are omitted for readability)
 </ul>
 
 Additionally you have the option to create artificial networks, for testing purposes. Currently choices are:
 <ul>
   <li> A regular lattice, where each node is placed in a cubic pattern and only connected to its neighbours
   <li> A heterogenic sphere, where one node is placed in the center and connected to all nodes on the shell
   <li> A random network, where nodes are randomly placed on a spherical shell and randomly connected
 </ul>
 
 \section QmitkBrainNetworkAnalysisUserManualTrouble Troubleshooting
 
 No known problems.
 
 <B>All other problems.</B><BR>
 Please report to the MITK mailing list.
 See http://www.mitk.org/wiki/Mailinglist on how to do this.
 */
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkDiffusionImagingUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkDiffusionImagingUserManual.dox
index 696214e6d4..5124408e30 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkDiffusionImagingUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkDiffusionImagingUserManual.dox
@@ -1,122 +1,122 @@
 /**
 \page org_mitk_gui_qt_diffusionimaging MITK Diffusion Imaging (MITK-DI)
 
 This module provides means to diffusion weighted image reconstruction, visualization and quantification. Diffusion tensors as well as different q-ball reconstruction schemes are supported. Q-ball imaging aims at recovering more detailed information about the orientations of fibers from diffusion MRI measurements and, in particular, to resolve the orientations of crossing fibers.
 
 Available sections:
   - \ref QmitkDiffusionImagingUserManualIssues
   - \ref QmitkDiffusionImagingUserManualPreprocessing
   - \ref QmitkDiffusionImagingUserManualTensorReconstruction
   - \ref QmitkDiffusionImagingUserManualQBallReconstruction
   - \ref QmitkDiffusionImagingUserManualDicomImport
   - \ref QmitkDiffusionImagingUserManualQuantification
   - \ref QmitkDiffusionImagingUserManualVisualizationSettings
   - \ref QmitkDiffusionImagingUserManualReferences
   - \ref QmitkDiffusionImagingUserManualTechnicalDetail
   - \ref QmitkDiffusionImagingUserManualSubManuals
 
 \section QmitkDiffusionImagingUserManualIssues Known Issues
 
 \li <b>Dicom Import:</b> The dicom import has so far only been implemented for Siemens dicom images. MITK-DI is capable of reading the nrrd format, which is documented elsewhere [1, 2]. These files can be created by combining the raw image data with a corresponding textual header file. The file extension should be changed from *.nrrd to *.dwi or from *.nhdr to *.hdwi respectively in order to let MITK-DI recognize the diffusion related header information provided in the files.
 
 \section QmitkDiffusionImagingUserManualPreprocessing Preprocessing
 
 The preprocessing view gives an overview over the important features of a diffusion weighted image like the number of gradient directions, b-value and the measurement frame. Additionally it allows the extraction of the B0 image, reduction of gradient directions and the generation of a binary brain mask. The image volume can be modified by applying a new mesurement frame, which is useful if the measurement frame is not set correctly in the image header, or by averaging redundant gradient directions.
 
 \image html prepro1.png Preprocessing
 
 \section QmitkDiffusionImagingUserManualTensorReconstruction Tensor Reconstruction
 
 The tensor reconstruction view allows ITK based tensor reconstruction [3]. The advanced settings for ITK reconstruction let you configure a manual threshold on the non-diffusion weighted image. All voxels below this threshold will not be reconstructed and left blank. It is also possible to check for negative eigenvalues. The according voxels are also left blank.
 
 \image html tensor1.png ITK tensor reconstruction
 
 A few seconds (depending on the image size) after the reconstruction button is hit, a colored image should appear in the main window.
 
 \image html tensor4.png Tensor image after reconstruction
 
 The view also allows the generation of artificial diffusion weighted or Q-Ball images from the selected tensor image. The ODFs of the Q-Ball image are directly initialized from the tensor values and afterwards normalized. The diffusion weighted image is estimated using the l2-norm image of the tensor image as B0. The gradient images are afterwards generated using the standard tensor equation.
 
 \section QmitkDiffusionImagingUserManualQBallReconstruction Q-Ball Reconstruction
 
-The q-ball reonstruction bundle implements a variety of reconstruction methods. The different reconstruction methods are described in the following:
+The q-ball reonstruction view implements a variety of reconstruction methods. The different reconstruction methods are described in the following:
 \li <b>Numerical:</b> The original, numerical q-ball reconstruction presented by Tuch et al. [5]
 \li <b>Standard (SH):</b> Descoteaux's reconstruction based on spherical harmonic basis functions [6]
 \li <b>Solid Angle (SH):</b> Aganj's reconstruction with solid angle consideration [7]
 \li <b>ADC-profile only:</b> The ADC-profile reconstructed with spherical harmonic basis functions
 \li <b>Raw signal only:</b> The raw signal reconstructed with spherical harmonic basis functions
 
 \image html qballs1.png The q-ball resonstruction view
 
 B0 threshold works the same as in tensor reconstruction. The maximum l-level configures the size of the spherical harmonics basis. Larger l-values (e.g. l=8) allow higher levels of detail, lower levels are more stable against noise (e.g. l=4). Lambda is a regularisation parameter. Set it to 0 for no regularisation. lambda = 0.006 has proven to be a stable choice under various settings.
 
 \image html qballs2.png Advanced q-ball reconstruction settings
 
 This is how a q-ball image should initially look after reconstruction. Standard q-balls feature a relatively low GFA and thus appear rather dark. Adjust the level-window to solve this.
 
 \image html qballs3.png q-ball image after reconstruction
 
 \section QmitkDiffusionImagingUserManualDicomImport Dicom Import
 
 The dicom import does not cover all hardware manufacturers but only Siemens dicom images. MITK-DI is also capable of reading the nrrd format, which is documented elsewhere [1, 2]. These files can be created by combining the raw image data with a corresponding textual header file. The file extension should be changed from *.nrrd to *.dwi or from *.nhdr to *.hdwi respectively in order to let MITK-DI recognize the diffusion related header information provided in the files.
 
 In case your dicom images are readable by MITK-DI, select one or more input dicom folders and click import. Each input folder must only contain DICOM-images that can be combined into one vector-valued 3D output volume. Different patients must be loaded from different input-folders. The folders must not contain other acquisitions (e.g. T1,T2,localizer).
 
 In case many imports are performed at once, it is recommended to set the the optional output folder argument. This prevents the images from being kept in memory.
 
 \image html dicom1.png Dicom import
 
 The option "Average duplicate gradients" accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a "blur radius" > 0 is configured.
 
 \section QmitkDiffusionImagingUserManualQuantification Quantification
 
 The quantification view allows the derivation of different scalar anisotropy measures for the reconstructed tensors (Fractional Anisotropy, Relative Anisotropy, Axial Diffusivity, Radial Diffusivity) or q-balls (Generalized Fractional Anisotropy).
 
 \image html quantification.png Anisotropy quantification
 
 \section QmitkDiffusionImagingUserManualVisualizationSettings ODF Visualization Setting
 
 In this small view, the visualization of ODFs and diffusion images can be configured. Depending on the selected image in the data storage, different options are shown here.
 
 For tensor or q-ball images, the visibility of glyphs in the different render windows (T)ransversal, (S)agittal, and (C)oronal can be configured here. The maximal number of glyphs to display can also be configured here for. This is usefull to keep the system response time during rendering feasible. The other options configure normalization and scaling of the glyphs.
 
 In diffusion images, a slider lets you choose the desired image channel from the vector of images (each gradient direction one image) for rendering. Furthermore reinit can be performed and texture interpolation toggled.
 
 This is how a visualization with activated glyphs should look like:
 
 \image html visualization3.png Q-ball image with ODF glyph visibility toggled ON
 
 \section QmitkDiffusionImagingUserManualReferences References
 
 1. http://teem.sourceforge.net/nrrd/format.html
 
 2. http://www.cmake.org/Wiki/Getting_Started_with_the_NRRD_Format
 
 3. C.F.Westin, S.E.Maier, H.Mamata, A.Nabavi, F.A.Jolesz, R.Kikinis, "Processing and visualization for Diffusion tensor MRI", Medical image Analysis, 2002, pp 93-108
 
 5. Tuch, D.S., 2004. Q-ball imaging. Magn Reson Med 52, 1358-1372.
 
 6. Descoteaux, M., Angelino, E., Fitzgibbons, S., Deriche, R., 2007. Regularized, fast, and robust analytical Q-ball imaging. Magn Reson Med 58, 497-510.
 
 7. Aganj, I., Lenglet, C., Sapiro, G., 2009. ODF reconstruction in q-ball imaging with solid angle consideration. Proceedings of the Sixth IEEE International Symposium on Biomedical Imaging Boston, MA.
 
 8. Goh, A., Lenglet, C., Thompson, P.M., Vidal, R., 2009. Estimating Orientation Distribution Functions with Probability Density Constraints and Spatial Regularity. Med Image Comput Comput Assist Interv Int Conf Med Image Comput Comput Assist Interv LNCS 5761, 877 ff.
 
 \section QmitkDiffusionImagingUserManualTechnicalDetail Technical Information for Developers
 
-The diffusion imaging module uses additional properties beside the ones in use in other modules, for further information see \subpage DiffusionImagingPropertiesPage .
+The diffusion imaging module uses additional properties beside the ones in use in other modules, for further information see \ref DiffusionImagingPropertiesPage .
 
 \section QmitkDiffusionImagingUserManualSubManuals Manuals of componentes
 
 The MITK Diffusion tools consist of further components, which have their own documentation, see:
 
   \li \subpage org_mitk_views_fiberprocessing
   \li \subpage org_mitk_views_gibbstracking
   \li \subpage org_mitk_views_odfdetails
   \li \subpage org_mitk_views_partialvolumeanalysisview
   \li \subpage org_mitk_views_screenshotmaker
   \li \subpage org_mitk_views_stochasticfibertracking
   \li \subpage org_mitk_views_ivim
   \li \subpage org_mitk_views_brainnetworkanalysis
   \li \subpage org_mitk_views_tractbasedspatialstatistics
 */
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkTbssViewUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkTbssViewUserManual.dox
index 2a199fd3a9..af6cbc7de5 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkTbssViewUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/documentation/UserManual/QmitkTbssViewUserManual.dox
@@ -1,59 +1,59 @@
 /**
-\page org_mitk_views_tractbasedspatialstatistics The TBSS Module
+\page org_mitk_views_tractbasedspatialstatistics The TBSS View
 
-\image html tbss.png "Icon of the Module"
+\image html tbss.png "Icon of the View"
 
 \section QmitkTractbasedSpatialStatistics Summary
 
-This module can be used to locally explore data resulting from preprocessing with the TBSS module of FSL
+This view can be used to locally explore data resulting from preprocessing with the TBSS view of FSL
 
-This document will tell you how to use this module, but it is assumed that you already know how to use MITK in general and how to work with the TBSS module of FSL.
+This document will tell you how to use this view, but it is assumed that you already know how to use MITK in general and how to work with the TBSS view of FSL.
 
-If you encounter problems using the module, please have a look at the \ref QmitkTractbasedSpatialStatisticsUserManualTrouble page.
+If you encounter problems using the view, please have a look at the \ref QmitkTractbasedSpatialStatisticsUserManualTrouble page.
 
 Sections:
 
 - \ref QmitkTractbasedSpatialStatisticsUserManualOverview 
 - \ref QmitkTractbasedSpatialStatisticsUserManualFSLImport
 - \ref QmitkTractbasedSpatialStatisticsUserManualRois
 - \ref QmitkTractbasedSpatialStatisticsUserManualProfiles
 - \ref QmitkTractbasedSpatialStatisticsUserManualTroubleshooting
 - \ref QmitkTractbasedSpatialStatisticsUserManualReferences
 
 \section QmitkTractbasedSpatialStatisticsUserManualOverview Overview
 
-This module is currently under development and as such the interface as well as the capabilities are likely to change significantly between different versions. 
+This view is currently under development and as such the interface as well as the capabilities are likely to change significantly between different versions. 
 
 This documentation describes the features of this current version.
 
 
 
 \section QmitkTractbasedSpatialStatisticsUserManualFSLImport FSL Import
 The FSL import allows to import data that has been preprocessed by FSL. FSL creates output images that typically have names like all_FA_skeletonized.nii.gz that are 4-dimensional images that contain registered images of all subjects. By loading this 4D image into the datamanager and listing the groups with the correct number of subjects, in the order of occurrence in the 4D image, in the TBSS-View using the Add button and clicking the import subject data a TBSS file is created that contains all the information needed for tract analysis. The diffusion measure of the image can be set as well.
 
 \image html fslimport.png "FSL Import"
 
 \section QmitkTractbasedSpatialStatisticsUserManualRois Regions of Interest (ROIs)
 To create a ROI the mean FA skeleton (typically called mean_FA_skeleton.nii.gz) that is created by FSL should be loaded in to the datamanager and selected. By using the Pointlistwidget points should be set on the skeleton (make sure to select points with relatively high FA values). Points are set by first selecting the button with the '+' and than shift-leftclick in the image. When the correct image is selected in the datamanager the Create ROI button is enabled. Clicking this will create a region of interest that passes through the previously selected points. The roi appears in the datamanager. Before doing so, the name of the roi and the information on the structure on which the ROI lies can be set. This will be saved as extra information in the roi-image. Before the ROI is calculated, a pop-up window will ask the user to provide a threshold value. This should be the same threshold that was previously used in FSL to create a binary mask of the FA skeleton. When this is not done correctly, the region of interest will possible contain zero-valued voxels.
 
 \image html tbssRoi.png "Regions of Interest (ROIs)"
 
 
 \section QmitkTractbasedSpatialStatisticsUserManualProfiles
 
 y selecting a tbss image with group information and a region of interest image (as was created in a previous stap). A profile plot is drawn in the plot canvas. By clicking in the graph the crosshairs jump to the corresponding location in the image.
 
 \image html profiles.png "Profile plots"
 
 \section QmitkTractbasedSpatialStatisticsUserManualTroubleshooting Troubleshooting
 
 Please report to the MITK mailing list.
 See http://www.mitk.org/wiki/Mailinglist on how to do this.
 
 
 
 \section QmitkTractbasedSpatialStatisticsUserManualReferences References
 1. S.M. Smith, M. Jenkinson, H. Johansen-Berg, D. Rueckert, T.E. Nichols, C.E. Mackay, K.E. Watkins, O. Ciccarelli, M.Z. Cader, P.M. Matthews, and T.E.J. Behrens. Tract-based spatial statistics: Voxelwise analysis of multi-subject diffusion data. NeuroImage, 31:1487-1505, 2006.
 
 2. S.M. Smith, M. Jenkinson, M.W. Woolrich, C.F. Beckmann, T.E.J. Behrens, H. Johansen-Berg, P.R. Bannister, M. De Luca, I. Drobnjak, D.E. Flitney, R. Niazy, J. Saunders, J. Vickers, Y. Zhang, N. De Stefano, J.M. Brady, and P.M. Matthews. Advances in functional and structural MR image analysis and implementation as FSL. NeuroImage, 23(S1):208-219, 2004.
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/ColorImageProcessing.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/ColorImageProcessing.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/ColorImageProcessing.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/ColorImageProcessing.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/IsoSurfaceGUI.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/IsoSurfaceGUI.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/IsoSurfaceGUI.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/IsoSurfaceGUI.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/IsoSurfaceIcon.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/IsoSurfaceIcon.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/IsoSurfaceIcon.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/IsoSurfaceIcon.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/MITKExamples.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/MITKExamples.dox
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/MITKExamples.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/MITKExamples.dox
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkColourImageProcessing.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkColourImageProcessing.dox
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkColourImageProcessing.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkColourImageProcessing.dox
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkIsoSurfaceUserManual.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkIsoSurfaceUserManual.dox
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkIsoSurfaceUserManual.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkIsoSurfaceUserManual.dox
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkRegionGrowingUserManual.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkRegionGrowingUserManual.dox
similarity index 71%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkRegionGrowingUserManual.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkRegionGrowingUserManual.dox
index 97360b23ea..2b1f8a2467 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkRegionGrowingUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkRegionGrowingUserManual.dox
@@ -1,29 +1,29 @@
 /**
-\page org_mitk_views_regiongrowing The Region Growing Module
+\page org_mitk_views_regiongrowing The Region Growing View
 
-\image html regiongrowing.png "Icon of the Module"
+\image html regiongrowing.png "Icon of the View"
 
 Available documentation sections:
 - \ref QmitkRegionGrowingUserManualOverview
 - \ref QmitkRegionGrowingUserManualUsage
 
 \section QmitkRegionGrowingUserManualOverview Overview
 
-The Region growing module provides a programming example, showing developers how to create new bundles for MITK with a graphical user interface (GUI) that also uses some ITK image filters. 
+The Region growing view provides a programming example, showing developers how to create new views for MITK with a graphical user interface (GUI) that also uses some ITK image filters. 
 
 <b>For the programmers:</b> this functionality is the result of <a href="http://docs.mitk.org/nightly/Step9Page.html">tutorial step 9</a>
 
 \section QmitkRegionGrowingUserManualUsage Usage
 
 <ul>
 
 <li> you can set a number of seed points by clicking into the render windows while holding down the shift key.
 </li>
 <li> when clicking "Start region growing", a region growing algorithm starts. This algorithm is gray values based. The gray values are determined from the gray values at all point positions plus/minus a safety margin of 30 (Hounsfield units).
 </li>
 </ul>
 
 
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkSimpleExampleUserManual.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkSimpleExampleUserManual.dox
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkSimpleExampleUserManual.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkSimpleExampleUserManual.dox
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkSimpleMeasurementUserManual.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkSimpleMeasurementUserManual.dox
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/QmitkSimpleMeasurementUserManual.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/QmitkSimpleMeasurementUserManual.dox
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleExample.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleExample.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleExample.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleExample.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleMeasurementGUI.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleMeasurementGUI.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleMeasurementGUI.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleMeasurementGUI.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleMeasurementIcon.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleMeasurementIcon.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/SimpleMeasurementIcon.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/SimpleMeasurementIcon.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/org_mitk_gui_qt_viewinitialization.dox b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/org_mitk_gui_qt_viewinitialization.dox
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/org_mitk_gui_qt_viewinitialization.dox
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/org_mitk_gui_qt_viewinitialization.dox
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/regiongrowing.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/regiongrowing.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/regiongrowing.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/regiongrowing.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/regiongrowing.xpm b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/regiongrowing.xpm
similarity index 95%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/regiongrowing.xpm
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/regiongrowing.xpm
index 45304646ee..5ba3fbe102 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/regiongrowing.xpm
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/regiongrowing.xpm
@@ -1,53 +1,53 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"28 26 24 1",
-" 	c None",
-".	c #000000",
-"+	c #639A31",
-"@	c #316500",
-"#	c #6B9A31",
-"$	c #94CF63",
-"%	c #396500",
-"&	c #9CCB6B",
-"*	c #94CB63",
-"=	c #9CCB63",
-"-	c #6B9639",
-";	c #316900",
-">	c #949A94",
-",	c #9C969C",
-"'	c #6B656B",
-")	c #CECBCE",
-"!	c #9C9A9C",
-"~	c #393039",
-"{	c #313431",
-"]	c #C6CFC6",
-"^	c #636963",
-"/	c #636563",
-"(	c #9C6500",
-"_	c #946500",
-"                ..          ",
-"               .+@.         ",
-"              .#$%.         ",
-"              .&+.   ....   ",
-"              .+.   .+&*@.  ",
-"               .   .=$#+%.  ",
-"                   .$....   ",
-"                    .       ",
-"     ............           ",
-"   ..+*&=+&++-+++..         ",
-"  .=-;%;@%@%;@@%;-+.   ...  ",
-"  .+@@@@%;@;%;%;@@&+. .++-. ",
-"  .%@-+=&+-++#++-*#+.  .&+@.",
-"  .>>@;@;;@;#+%+;@;-.   .&%.",
-"  .,'))>!'>'=+%;'~{+.    .;.",
-"  .>!])'!^!{-+;//{{-@.    . ",
-"  .!'))>!'{~;&@'{/~+@.      ",
-" .(>>)]'>{{/'@/{'{{+%.      ",
-"._{{{{{{~{,'^'/'/{~@@.      ",
-" .(,>))/>/!//^'^{'{..       ",
-"  .>/])>,/>'/'/~^{{.        ",
-"  .!,>>'>'>/^/^'/~{./^      ",
-"  .{{!'!!'>''''/~{{.''//'/  ",
-"  /..{{~{{~{{{{{{../^^/'^'' ",
-"   ^/............'^/''^'//  ",
-"       /'^'/^'//^//'//      "};
+/* XPM */
+static const char * icon_xpm[] = {
+"28 26 24 1",
+" 	c None",
+".	c #000000",
+"+	c #639A31",
+"@	c #316500",
+"#	c #6B9A31",
+"$	c #94CF63",
+"%	c #396500",
+"&	c #9CCB6B",
+"*	c #94CB63",
+"=	c #9CCB63",
+"-	c #6B9639",
+";	c #316900",
+">	c #949A94",
+",	c #9C969C",
+"'	c #6B656B",
+")	c #CECBCE",
+"!	c #9C9A9C",
+"~	c #393039",
+"{	c #313431",
+"]	c #C6CFC6",
+"^	c #636963",
+"/	c #636563",
+"(	c #9C6500",
+"_	c #946500",
+"                ..          ",
+"               .+@.         ",
+"              .#$%.         ",
+"              .&+.   ....   ",
+"              .+.   .+&*@.  ",
+"               .   .=$#+%.  ",
+"                   .$....   ",
+"                    .       ",
+"     ............           ",
+"   ..+*&=+&++-+++..         ",
+"  .=-;%;@%@%;@@%;-+.   ...  ",
+"  .+@@@@%;@;%;%;@@&+. .++-. ",
+"  .%@-+=&+-++#++-*#+.  .&+@.",
+"  .>>@;@;;@;#+%+;@;-.   .&%.",
+"  .,'))>!'>'=+%;'~{+.    .;.",
+"  .>!])'!^!{-+;//{{-@.    . ",
+"  .!'))>!'{~;&@'{/~+@.      ",
+" .(>>)]'>{{/'@/{'{{+%.      ",
+"._{{{{{{~{,'^'/'/{~@@.      ",
+" .(,>))/>/!//^'^{'{..       ",
+"  .>/])>,/>'/'/~^{{.        ",
+"  .!,>>'>'>/^/^'/~{./^      ",
+"  .{{!'!!'>''''/~{{.''//'/  ",
+"  /..{{~{{~{{{{{{../^^/'^'' ",
+"   ^/............'^/''^'//  ",
+"       /'^'/^'//^//'//      "};
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/viewInitializationIcon.png b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/viewInitializationIcon.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/viewInitializationIcon.png
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/viewInitializationIcon.png
diff --git a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/viewInitializationIcon.xpm b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/viewInitializationIcon.xpm
similarity index 93%
rename from Plugins/org.mitk.gui.qt.examples/documentation/Manual/viewInitializationIcon.xpm
rename to Plugins/org.mitk.gui.qt.examples/documentation/UserManual/viewInitializationIcon.xpm
index 819882324c..11ccbcc699 100644
--- a/Plugins/org.mitk.gui.qt.examples/documentation/Manual/viewInitializationIcon.xpm
+++ b/Plugins/org.mitk.gui.qt.examples/documentation/UserManual/viewInitializationIcon.xpm
@@ -1,17 +1,17 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"11 11 3 1",
-" 	c None",
-".	c #CBCBCB",
-"+	c #404040",
-"+++++++++++",
-"+..+...+..+",
-"+++++++++++",
-"+..+...+..+",
-"+..+...+..+",
-"+++++++++++",
-"+..+...+..+",
-"+..+...+..+",
-"+++++++++++",
-"+..+...+..+",
-"+++++++++++"};
+/* XPM */
+static const char * icon_xpm[] = {
+"11 11 3 1",
+" 	c None",
+".	c #CBCBCB",
+"+	c #404040",
+"+++++++++++",
+"+..+...+..+",
+"+++++++++++",
+"+..+...+..+",
+"+..+...+..+",
+"+++++++++++",
+"+..+...+..+",
+"+..+...+..+",
+"+++++++++++",
+"+..+...+..+",
+"+++++++++++"};
diff --git a/Plugins/org.mitk.gui.qt.ext/resources/dcm-icon.png b/Plugins/org.mitk.gui.qt.ext/resources/dcm-icon.png
new file mode 100644
index 0000000000..f1d529ee3a
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.ext/resources/dcm-icon.png differ
diff --git a/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_gui_qt_ext.qrc b/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_gui_qt_ext.qrc
index 9aaabf6cd5..2e85bf72fc 100644
--- a/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_gui_qt_ext.qrc
+++ b/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_gui_qt_ext.qrc
@@ -1,11 +1,12 @@
 <RCC>
     <qresource prefix="/org.mitk.gui.qt.ext" >
         <file>Load_48.png</file>
         <file>Redo_48.png</file>
         <file>Save_48.png</file>
         <file>Undo_48.png</file>
         <file>Remove_48.png</file>
+        <file>dcm-icon.png</file>
         <file>Slider.png</file>
         <file>index.html</file>
     </qresource>
 </RCC>
diff --git a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
index 24e66118cc..b6acb9ba4d 100644
--- a/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
+++ b/Plugins/org.mitk.gui.qt.ext/src/QmitkExtWorkbenchWindowAdvisor.cpp
@@ -1,1190 +1,1190 @@
 /*===================================================================
 
 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 "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 <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryIPerspectiveDescriptor.h>
 #include <berryIWorkbenchPartConstants.h>
 
 #include <internal/berryQtShowViewAction.h>
 #include <internal/berryQtOpenPerspectiveAction.h>
 
 #include <QmitkFileOpenAction.h>
 #include <QmitkExtFileSaveProjectAction.h>
 #include <QmitkFileExitAction.h>
 #include <QmitkCloseProjectAction.h>
 #include <QmitkDefaultDropTargetListener.h>
 #include <QmitkStatusBar.h>
 #include <QmitkProgressBar.h>
 #include <QmitkMemoryUsageIndicatorView.h>
 #include <QmitkPreferencesDialog.h>
 #include <QmitkOpenDicomEditorAction.h>
 
 #include <itkConfigure.h>
 #include <vtkConfigure.h>
 #include <mitkVersion.h>
 #include <mitkIDataStorageService.h>
 #include <mitkIDataStorageReference.h>
 #include <mitkDataStorageEditorInput.h>
 #include <mitkWorkbenchUtil.h>
 
 // UGLYYY
 #include "internal/QmitkExtWorkbenchWindowAdvisorHack.h"
 #include "internal/QmitkCommonExtPlugin.h"
 #include "mitkUndoController.h"
 #include "mitkVerboseLimitedLinearUndo.h"
 #include <QToolBar>
 #include <QMessageBox>
 #include <QLabel>
 #include <QmitkAboutDialog/QmitkAboutDialog.h>
 
 QmitkExtWorkbenchWindowAdvisorHack
 * QmitkExtWorkbenchWindowAdvisorHack::undohack =
 new QmitkExtWorkbenchWindowAdvisorHack();
 
 QString QmitkExtWorkbenchWindowAdvisor::QT_SETTINGS_FILENAME = "QtSettings.ini";
 
 class PartListenerForTitle: public berry::IPartListener
 {
 public:
 
  PartListenerForTitle(QmitkExtWorkbenchWindowAdvisor* wa) :
    windowAdvisor(wa)
    {
    }
 
    Events::Types GetPartEventTypes() const
    {
     return Events::ACTIVATED | Events::BROUGHT_TO_TOP | Events::CLOSED
      | Events::HIDDEN | Events::VISIBLE;
    }
 
    void PartActivated(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref.Cast<berry::IEditorReference> ())
     {
      windowAdvisor->UpdateTitle(false);
     }
    }
 
    void PartBroughtToTop(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref.Cast<berry::IEditorReference> ())
     {
      windowAdvisor->UpdateTitle(false);
     }
    }
 
    void PartClosed(berry::IWorkbenchPartReference::Pointer /*ref*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PartHidden(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (!windowAdvisor->lastActiveEditor.Expired() &&
      ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
     {
      windowAdvisor->UpdateTitle(true);
     }
    }
 
    void PartVisible(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (!windowAdvisor->lastActiveEditor.Expired() &&
      ref->GetPart(false) == windowAdvisor->lastActiveEditor.Lock())
     {
      windowAdvisor->UpdateTitle(false);
     }
    }
 
 private:
  QmitkExtWorkbenchWindowAdvisor* windowAdvisor;
 
 };
 
 class PartListenerForImageNavigator: public berry::IPartListener
 {
 public:
 
  PartListenerForImageNavigator(QAction* act) :
    imageNavigatorAction(act)
    {
    }
 
    Events::Types GetPartEventTypes() const
    {
     return Events::OPENED | Events::CLOSED | Events::HIDDEN |
      Events::VISIBLE;
    }
 
    void PartOpened(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(true);
     }
    }
 
    void PartClosed(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(false);
     }
    }
 
    void PartVisible(berry::IWorkbenchPartReference::Pointer ref)
    {
     if (ref->GetId()=="org.mitk.views.imagenavigator")
     {
      imageNavigatorAction->setChecked(true);
     }
    }
 
    void PartHidden(berry::IWorkbenchPartReference::Pointer ref)
    {
     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
    {
     return Events::ACTIVATED | Events::SAVED_AS | Events::DEACTIVATED
      // remove the following line when command framework is finished
      | Events::CLOSED | Events::OPENED;
    }
 
    void PerspectiveActivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PerspectiveSavedAs(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*oldPerspective*/,
     berry::IPerspectiveDescriptor::Pointer /*newPerspective*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PerspectiveDeactivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     windowAdvisor->UpdateTitle(false);
    }
 
    void PerspectiveOpened(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     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.dicomeditor"))
      {
         windowAdvisor->openDicomEditorAction->setEnabled(true);
      }
      windowAdvisor->fileSaveProjectAction->setEnabled(true);
      windowAdvisor->closeProjectAction->setEnabled(true);
      windowAdvisor->undoAction->setEnabled(true);
      windowAdvisor->redoAction->setEnabled(true);
      windowAdvisor->imageNavigatorAction->setEnabled(true);
      windowAdvisor->resetPerspAction->setEnabled(true);
      if( windowAdvisor->GetShowClosePerspectiveMenuItem() )
      {
        windowAdvisor->closePerspAction->setEnabled(true);
      }
     }
 
     perspectivesClosed = false;
    }
 
    void PerspectiveClosed(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer /*perspective*/)
    {
     berry::IWorkbenchWindow::Pointer wnd = windowAdvisor->GetWindowConfigurer()->GetWindow();
     bool allClosed = true;
     if (wnd->GetActivePage())
     {
      std::vector<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.dicomeditor"))
      {
         windowAdvisor->openDicomEditorAction->setEnabled(false);
      }
      windowAdvisor->fileSaveProjectAction->setEnabled(false);
      windowAdvisor->closeProjectAction->setEnabled(false);
      windowAdvisor->undoAction->setEnabled(false);
      windowAdvisor->redoAction->setEnabled(false);
      windowAdvisor->imageNavigatorAction->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
    {
     return Events::ACTIVATED | Events::DEACTIVATED;
    }
 
    void PerspectiveActivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer perspective)
    {
      QAction* action = windowAdvisor->mapPerspIdToAction[perspective->GetId()];
      if (action)
      {
        action->setChecked(true);
      }
    }
 
    void PerspectiveDeactivated(berry::IWorkbenchPage::Pointer /*page*/,
     berry::IPerspectiveDescriptor::Pointer perspective)
    {
      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(0),
 wbAdvisor(wbAdvisor),
 showViewToolbar(true),
 showPerspectiveToolbar(false),
 showVersionInfo(true),
 showMitkVersionInfo(true),
 showViewMenuItem(true),
 showNewWindowMenuItem(false),
 showClosePerspectiveMenuItem(true),
 dropTargetListener(new QmitkDefaultDropTargetListener)
 {
- productName = berry::Platform::GetConfiguration().getString("application.baseName");
+ productName = QCoreApplication::applicationName().toStdString();
 }
 
 berry::ActionBarAdvisor::Pointer QmitkExtWorkbenchWindowAdvisor::CreateActionBarAdvisor(
  berry::IActionBarConfigurer::Pointer configurer)
 {
  berry::ActionBarAdvisor::Pointer actionBarAdvisor(
   new QmitkExtActionBarAdvisor(configurer));
  return actionBarAdvisor;
 }
 
 void* QmitkExtWorkbenchWindowAdvisor::CreateEmptyWindowContents(void* parent)
 {
  QWidget* parentWidget = static_cast<QWidget*>(parent);
  QLabel* 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::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 std::string& product)
 {
  productName = product;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetWindowIcon(const std::string& wndIcon)
 {
  windowIcon = wndIcon;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
 {
  // very bad hack...
  berry::IWorkbenchWindow::Pointer window =
   this->GetWindowConfigurer()->GetWindow();
  QMainWindow* mainWindow =
   static_cast<QMainWindow*> (window->GetShell()->GetControl());
 
  if (!windowIcon.empty())
  {
   mainWindow->setWindowIcon(QIcon(QString::fromStdString(windowIcon)));
  }
  mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
 
  /*mainWindow->setStyleSheet("color: white;"
  "background-color: #808080;"
  "selection-color: #659EC7;"
  "selection-background-color: #808080;"
  " QMenuBar {"
  "background-color: #808080; }");*/
 
  // ==== Application menu ============================
  QMenuBar* menuBar = mainWindow->menuBar();
  menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
 
  QMenu* fileMenu = menuBar->addMenu("&File");
  fileMenu->setObjectName("FileMenu");
 
  QAction* fileOpenAction = new QmitkFileOpenAction(QIcon(":/org.mitk.gui.qt.ext/Load_48.png"), window);
  fileMenu->addAction(fileOpenAction);
  fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
  fileSaveProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Save_48.png"));
  fileMenu->addAction(fileSaveProjectAction);
  closeProjectAction = new QmitkCloseProjectAction(window);
  closeProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Remove_48.png"));
  fileMenu->addAction(closeProjectAction);
  fileMenu->addSeparator();
  QAction* fileExitAction = new QmitkFileExitAction(window);
  fileExitAction->setObjectName("QmitkFileExitAction");
  fileMenu->addAction(fileExitAction);
 
 if(this->GetWindowConfigurer()->GetWindow()->GetWorkbench()->GetEditorRegistry()->FindEditor("org.mitk.editors.dicomeditor"))
 {
- openDicomEditorAction = new QmitkOpenDicomEditorAction(window);
+ openDicomEditorAction = new QmitkOpenDicomEditorAction(QIcon(":/org.mitk.gui.qt.ext/dcm-icon.png"),window);
 }
 
  berry::IViewRegistry* viewRegistry =
   berry::PlatformUI::GetWorkbench()->GetViewRegistry();
  const std::vector<berry::IViewDescriptor::Pointer>& viewDescriptors =
   viewRegistry->GetViews();
 
  // another bad hack to get an edit/undo menu...
  QMenu* editMenu = menuBar->addMenu("&Edit");
  undoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Undo_48.png"),
   "&Undo",
   QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
   QKeySequence("CTRL+Z"));
  undoAction->setToolTip("Undo the last action (not supported by all modules)");
  redoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Redo_48.png")
   , "&Redo",
   QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
   QKeySequence("CTRL+Y"));
  redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
 
  imageNavigatorAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/Slider.png"), "&Image Navigator", NULL);
  bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
  if (imageNavigatorViewFound)
  {
    QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
    imageNavigatorAction->setCheckable(true);
 
    // add part listener for image navigator
    imageNavigatorPartListener = new PartListenerForImageNavigator(imageNavigatorAction);
    window->GetPartService()->AddPartListener(imageNavigatorPartListener);
    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("Open image navigator for navigating through image");
  }
 
  // toolbar for showing file open, undo, redo and other main actions
  QToolBar* mainActionsToolBar = new QToolBar;
  mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
 #ifdef __APPLE__
  mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
 #else
  mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
 #endif
 
  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.dicomeditor"))
 {
  mainActionsToolBar->addAction(openDicomEditorAction);
 }
  if (imageNavigatorViewFound)
  {
    mainActionsToolBar->addAction(imageNavigatorAction);
  }
  mainWindow->addToolBar(mainActionsToolBar);
 
 #ifdef __APPLE__
  mainWindow->setUnifiedTitleAndToolBarOnMac(true);
 #endif
 
  // ==== 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;
  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();
  QActionGroup* perspGroup = new QActionGroup(menuBar);
 
  std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(
   perspRegistry->GetPerspectives());
 
     bool skip = false;
     for (std::vector<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 (unsigned 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(std::make_pair((*perspIt)->GetId(), perspAction));
     }
  perspMenu->addActions(perspGroup->actions());
 
  // sort elements (converting vector to map...)
  std::vector<berry::IViewDescriptor::Pointer>::const_iterator iter;
  std::map<std::string, berry::IViewDescriptor::Pointer> VDMap;
 
  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 (unsigned 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;
 
   std::pair<std::string, berry::IViewDescriptor::Pointer> p(
    (*iter)->GetLabel(), (*iter));
   VDMap.insert(p);
  }
  // ==================================================
 
   // ==== Perspective Toolbar ==================================
  QToolBar* qPerspectiveToolbar = new QToolBar;
 
  if (showPerspectiveToolbar)
  {
   qPerspectiveToolbar->addActions(perspGroup->actions());
   mainWindow->addToolBar(qPerspectiveToolbar);
  }
  else
   delete qPerspectiveToolbar;
 
  // ==== View Toolbar ==================================
  QToolBar* qToolbar = new QToolBar;
 
  std::map<std::string, 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(showViewMenuItem)
     viewMenu->addAction(viewAction);
   if (showViewToolbar)
   {
    qToolbar->addAction(viewAction);
   }
  }
 
  if (showViewToolbar)
  {
   mainWindow->addToolBar(qToolbar);
  }
  else
   delete qToolbar;
 
  QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
  mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
 
 
  // ====================================================
 
  // ===== 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()));
  // =====================================================
 
 
  QStatusBar* qStatusBar = new QStatusBar();
 
  //creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
  QmitkStatusBar *statusBar = new QmitkStatusBar(qStatusBar);
  //disabling the SizeGrip in the lower right corner
  statusBar->SetSizeGripEnabled(false);
 
 
 
  QmitkProgressBar *progBar = new QmitkProgressBar();
 
  qStatusBar->addPermanentWidget(progBar, 0);
  progBar->hide();
 // progBar->AddStepsToDo(2);
 // progBar->Progress(1);
 
  mainWindow->setStatusBar(qStatusBar);
 
  QmitkMemoryUsageIndicatorView* 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 = new PerspectiveListenerForMenu(this);
  configurer->GetWindow()->AddPerspectiveListener(menuPerspectiveListener);
 
  configurer->AddEditorAreaTransfer(QStringList("text/uri-list"));
  configurer->ConfigureEditorAreaDropListener(dropTargetListener);
 
 }
 
 void QmitkExtWorkbenchWindowAdvisor::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);
     }
   }
 }
 
 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";
  }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onImageNavigator()
 {
  // get ImageNavigatorView
  berry::IViewPart::Pointer imageNavigatorView =
   berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->FindView("org.mitk.views.imagenavigator");
  if (imageNavigatorView)
  {
   bool isImageNavigatorVisible = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->IsPartVisible(imageNavigatorView);
   if (isImageNavigatorVisible)
   {
    berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->HideView(imageNavigatorView);
    return;
   }
  }
  berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ShowView("org.mitk.views.imagenavigator");
  //berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->ResetPerspective();
 }
 
 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(0);
 }
 
 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); // Als Text-Datei nur zum Lesen öffnen
 
   QString text = QString(file.readAll());
 
   file.close();
 
   QString title = text;
   title.replace(reg, "");
   title.replace(reg2, "");
 
   std::cout << title.toStdString() << std::endl;
 
   QMessageBox::information(NULL, title,
    text, "Close");
 
  }
  else
  {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
    berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow(), false);
  }
 }
 
 void QmitkExtWorkbenchWindowAdvisorHack::onHelp()
 {
   ctkPluginContext* context = QmitkCommonExtPlugin::getContext();
   if (context == 0)
   {
     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 = 0;
   if (eventAdminRef)
   {
     eventAdmin = context->getService<ctkEventAdmin>(eventAdminRef);
   }
   if (eventAdmin == 0)
   {
     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()
 {
  QmitkAboutDialog* aboutDialog = new QmitkAboutDialog(QApplication::activeWindow(),NULL);
  aboutDialog->open();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::HookTitleUpdateListeners(
  berry::IWorkbenchWindowConfigurer::Pointer configurer)
 {
  // hook up the listeners to update the window title
  titlePartListener = new PartListenerForTitle(this);
  titlePerspectiveListener = new PerspectiveListenerForTitle(this);
  editorPropertyListener = 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);
  configurer->GetWindow()->GetPartService()->AddPartListener(titlePartListener);
 }
 
 std::string QmitkExtWorkbenchWindowAdvisor::ComputeTitle()
 {
  berry::IWorkbenchWindowConfigurer::Pointer configurer =
   GetWindowConfigurer();
  berry::IWorkbenchPage::Pointer currentPage =
   configurer->GetWindow()->GetActivePage();
  berry::IEditorPart::Pointer activeEditor;
  if (currentPage)
  {
   activeEditor = lastActiveEditor.Lock();
  }
 
  std::string title;
  //TODO Product
  //    IProduct product = Platform.getProduct();
  //    if (product != null) {
  //      title = product.getName();
  //    }
  // instead of the product name, we use a custom variable for now
  title = productName;
 
  if(showMitkVersionInfo)
  {
    title += std::string(" ") + MITK_VERSION_STRING;
  }
 
  if (showVersionInfo)
  {
   // add version informatioin
   QString versions = QString(" (ITK %1.%2.%3  VTK %4.%5.%6 Qt %7 MITK %8)")
    .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)
    .arg(MITK_VERSION_STRING);
 
   title += versions.toStdString();
  }
 
  if (currentPage)
  {
   if (activeEditor)
   {
    lastEditorTitle = activeEditor->GetTitleToolTip();
    if (!lastEditorTitle.empty())
     title = lastEditorTitle + " - " + title;
   }
   berry::IPerspectiveDescriptor::Pointer persp =
    currentPage->GetPerspective();
   std::string label = "";
   if (persp)
   {
    label = persp->GetLabel();
   }
   berry::IAdaptable* input = currentPage->GetInput();
   if (input && input != wbAdvisor->GetDefaultPageInput())
   {
    label = currentPage->GetLabel();
   }
   if (!label.empty())
   {
    title = label + " - " + title;
   }
  }
 
  title += " (Not for use in diagnosis or treatment of patients)";
 
  return title;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::RecomputeTitle()
 {
  berry::IWorkbenchWindowConfigurer::Pointer configurer =
   GetWindowConfigurer();
  std::string oldTitle = configurer->GetTitle();
  std::string 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 = 0;
 
  if (currentPage)
  {
   activeEditor = currentPage->GetActiveEditor();
   persp = currentPage->GetPerspective();
   input = currentPage->GetInput();
  }
 
  if (editorHidden)
  {
   activeEditor = 0;
  }
 
  // 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())
  {
   lastActiveEditor.Lock()->RemovePropertyListener(editorPropertyListener);
  }
 
  lastActiveEditor = activeEditor;
  lastActivePage = currentPage;
  lastPerspective = persp;
  lastInput = input;
 
  if (activeEditor)
  {
   activeEditor->AddPropertyListener(editorPropertyListener);
  }
 
  RecomputeTitle();
 }
 
 void QmitkExtWorkbenchWindowAdvisor::PropertyChange(berry::Object::Pointer /*source*/, int propId)
 {
  if (propId == berry::IWorkbenchPartConstants::PROP_TITLE)
  {
   if (!lastActiveEditor.Expired())
   {
    std::string newTitle = lastActiveEditor.Lock()->GetPartName();
    if (lastEditorTitle != newTitle)
    {
     RecomputeTitle();
    }
   }
  }
 }
 
 
 void QmitkExtWorkbenchWindowAdvisor::SetPerspectiveExcludeList(std::vector<std::string> v)
 {
   this->perspectiveExcludeList = v;
 }
 
 std::vector<std::string> QmitkExtWorkbenchWindowAdvisor::GetPerspectiveExcludeList()
 {
   return this->perspectiveExcludeList;
 }
 
 void QmitkExtWorkbenchWindowAdvisor::SetViewExcludeList(std::vector<std::string> v)
 {
   this->viewExcludeList = v;
 }
 
 std::vector<std::string> 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.extapplication/documentation/UserManual/QmitkMITKWorkbenchUserManual.dox b/Plugins/org.mitk.gui.qt.extapplication/documentation/UserManual/QmitkMITKWorkbenchUserManual.dox
index f941fe82be..1854351290 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/documentation/UserManual/QmitkMITKWorkbenchUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.extapplication/documentation/UserManual/QmitkMITKWorkbenchUserManual.dox
@@ -1,17 +1,17 @@
 /**
 \page org_mitkworkbench Using The MITK Workbench
 
 \section QMitkMitkWorkbenchManualOverview  What is the MITK Workbench
 
 The MITK Workbench is used by developers. As such the kind and number of views it contains is highly variable and dependent on the specific build. Typically it contains no special perspectives and whatever views the developer deemed desirable. Be aware, that it may contain views which are work in progress and may behave erratically.
 
 If you have been given such an executable by someone, please refer to the appropriate section of the online documentation for up to date usage information on any module. 
 
-<a href="http://docs.mitk.org/nightly-qt4/ModuleListPage.html">Nightly online documentation</a>
+<a href="http://docs.mitk.org/nightly-qt4/PluginListPage.html">Nightly online documentation</a>
 
 
 If you are using a nightly installer, the MITK Workbench will contain nearly all views available in MITK and as such most likely will seem confusing. Again the list of modules might be a good starting point if you want to have a rough idea of what could be of interest to you. 
 
 For a basic guide to MITK see \ref MITKUserManualPage .
 
 */
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/function.js b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/function.js
index 513330f719..504df84362 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/function.js
+++ b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/function.js
@@ -1,257 +1,259 @@
 // If you want to create a new button you have to add some data (strings) to the following five arrays.
 // Make sure that you add your data at the same position in each array.
 // The buttons will be generated in order to the array's index. e.g. data at array's index '0' will generate the first button.
 
 // enter the name of your module here
-var moduleNames = new Array("MITK Downloads & News");
+var moduleNames = new Array("MITK Website");
 
 // add the MITK-link to your module
-var moduleLinks = new Array("http://www.mitk.org");
+var moduleLinks = new Array("http://www.mitk.org/");
 
 // add the filename of your icon for the module. Place the picture in subdirectory "pics".
 // The picture's width should be 136 pixel; the height 123 pixel.
 var picFilenames = new Array("button_mitk.png");
 
 // if you want to create an animated icon, add the name of your animated gif (placed in subdirectory "pics"). Otherwise enter an empty string "".
 // The animation's width should be 136 pixel; the height 123 pixel.
 var aniFilenames = new Array("button_mitka.png");
 
 // if your module is not stable, you can mark it as experimental.
 // just set true for experimental or false for stable.
 var experimental = new Array(false);
 
 // add the description for your module. The description is displayed in a PopUp-window.
-var moduleDescriptions = new Array("Open the MITK website in an external browser.");
+var moduleDescriptions = new Array("");
 
 var bttns = new Array();
 
 var d = document, da = d.all;
 
 // holds id of current mouseover-HTML-element
 var currentTarget;
 
 // get the id of current mouseover-HTML-element
 d.onmouseover = function(o){
   var e = da ? event.srcElement : o.target;
   currentTarget = e.id;
 }
 
 
 // build-function called by onload-event in HTML-document
 function createButtons(){
 
   for (i=0; i < moduleNames.length; i++){
     bttns[i] = new Button(moduleNames[i],moduleLinks[i], picFilenames[i], aniFilenames[i],moduleDescriptions[i]);
     bttns[i].createButton();
   }
 
   for (i=0; i < moduleNames.length; i++){
 
     if(experimental[i]){
       setExperimental(i);
     }
   }
 
   createClearFloat();
 }
 
 // Class Button
 function Button(moduleName, moduleLink, picFilename, aniFilename, moduleDescr){
 
   // Properties
   this.bttnID = "bttn" + moduleName;
   this.modName = moduleName;
   this.modLink = moduleLink;
   this.picPath = "pics/" + picFilename;
   this.aniPath = "pics/" + aniFilename;
   this.modDescr = moduleDescr;
 
   // Methods
   this.createButton = function(){
 
     // get DIV-wrapper for Button and append it to HTML-document
     bttnWrapper = this.createWrapper();
     document.getElementById("bttnField").appendChild(bttnWrapper);
 
     // get link-element for picture and append it to DIV-wrapper
     bttnPicLink = this.createPicLink();
     bttnWrapper.appendChild(bttnPicLink);
 
     // set HTML attributes for button-element
     bttn = document.createElement("img");
     bttn.src = this.picPath;
     bttn.id = this.bttnID;
     bttn.className = "modBttn";
     bttn.height = 123;
     bttn.width = 136;
     bttn.onmouseover = function(){startAni(this.id);};
     bttn.onmouseout = function(){stopAni(this.id);};
 
     // append button to link-element
     bttnPicLink.appendChild(bttn);
 
     // create text-link and add it to DIV-wrapper
     bttnTxtLink = document.createElement("a");
     bttnTxtLink.href = this.modLink;
     bttnTxtLink.className = "txtLink";
     bttnTxtLink.appendChild(document.createTextNode(this.modName));
     bttnWrapper.appendChild(bttnTxtLink);
 
     // create pop-up link for module description
-    bttnPopUpLink = document.createElement("a");
-    modName = this.modName;
-    modDescr = this.modDescr;
-    bttnPopUpLink.onclick = function(){showPopUpWindow();};
-    bttnPopUpLink.className = "popUpLink";
-    bttnPopUpLink.id = "popup" + this.modName;
-    bttnPopUpLink.appendChild(document.createTextNode("more info >>"));
-    bttnWrapper.appendChild(document.createElement("br"));
-    bttnWrapper.appendChild(bttnPopUpLink);
+    if (this.modDescr.length != 0) {
+      bttnPopUpLink = document.createElement("a");
+      modName = this.modName;
+      modDescr = this.modDescr;
+      bttnPopUpLink.onclick = function(){showPopUpWindow();};
+      bttnPopUpLink.className = "popUpLink";
+      bttnPopUpLink.id = "popup" + this.modName;
+      bttnPopUpLink.appendChild(document.createTextNode("more info >>"));
+      bttnWrapper.appendChild(document.createElement("br"));
+      bttnWrapper.appendChild(bttnPopUpLink);
+    }
 
     return bttn;
   }
 
   this.createWrapper = function(){
     bttnWrapper = document.createElement("div");
     bttnWrapper.id = "wrapper" + this.modName;
     bttnWrapper.className = "bttnWrap";
 
     return bttnWrapper;
   }
 
   this.createPicLink = function(){
     picLink = document.createElement("a");
     picLink.href = this.modLink;
     picLink.id = "link" + this.modName;
 
     return picLink;
   }
 
 }
 
 
 function showPopUpWindow(){
 
   // modules position in array?
   modulePos = getPos(currentTarget,"popup");
 
   // get reference to anchor-element in HTML-document
   popUpAnchor = document.getElementById("popupAnchor");
 
   // check if a popUp is open
   if(popUpAnchor.hasChildNodes()){
     // if a popUp is open, remove it!
     popUpAnchor.removeChild(document.getElementById("popup"));
   }
 
   // create new container for popUp
   container = document.createElement("div");
   container.id = "popup";
   container.align = "right";
 
   // append popUp-container to HTML-document
   popUpAnchor.appendChild(container);
 
   // create close-button and append it to popUp-container
   bttnClose = document.createElement("img");
   bttnClose.src = "pics/popup_bttn_close.png";
   bttnClose.id = "bttnClose";
   bttnClose.onclick = function(){closeInfoWindow();};
   container.appendChild(bttnClose);
 
   // create container for content-elements
   contHeadline = document.createElement("div");
   contHeadline.id = "contHeadline";
   contDescription = document.createElement("div");
   contDescription.id = "contDescription";
   contModLink = document.createElement("div");
   contModLink.id = "contModLink";
 
   // append content-container to popUp-container
   container.appendChild(contHeadline);
   container.appendChild(contDescription);
   container.appendChild(contModLink);
 
   // create text-elements with content
   headline = document.createTextNode(moduleNames[modulePos] + " ");
   description = document.createTextNode(moduleDescriptions[modulePos]);
   moduleLink = document.createElement("a");
   moduleLink.href = moduleLinks[modulePos] ;
   moduleLink.className = 'moduleLink';
   moduleLinkTxt = document.createTextNode("Click here to open '" + moduleNames[modulePos].toLowerCase() + "'");
   moduleLink.appendChild(moduleLinkTxt);
 
   // append text-elements to their container
   contHeadline.appendChild(headline);
   contDescription.appendChild(description);
   contModLink.appendChild(moduleLink);
 }
 
 function getPos(id,prefix){
 
   if(prefix == "popup"){
     targetID = id.slice(5);
   }else{
     if(prefix == "bttn"){
       targetID = id.slice(4);
     }
   }
 
   for(i=0; i < moduleNames.length; i++ ){
     if(moduleNames[i] == targetID){
       return i;
     }
   }
 }
 
 function setExperimental(modPos){
   linkID = "link" + moduleNames[modPos];
 
   expPic = document.createElement("img");
   expPic.src = "pics/experimental.png";
   expPic.className = "expPic";
   //alert(bttns[modPos].bttnID);
   expPic.onmouseover = function(){startAni(bttns[modPos].bttnID);changeToHover(bttns[modPos].bttnID);};
   expPic.onmouseout = function(){stopAni(bttns[modPos].bttnID);changeToNormal(bttns[modPos].bttnID);};
 
   document.getElementById(linkID).appendChild(expPic);
 }
 
 function changeToHover(targetId){
   bttn = document.getElementById(targetId);
   bttn.className = "modBttnHover";
 }
 
 function changeToNormal(targetId){
   bttn = document.getElementById(targetId);
   bttn.className = "modBttn";
 }
 
 // function to close PopUp-window
 function closeInfoWindow(){
   popUpAnchor = document.getElementById("popupAnchor");
   popUpAnchor.removeChild(document.getElementById("popup"));
 }
 
 function createClearFloat(){
   cf = document.createElement("div");
   cf.className = "clearfloat";
   document.getElementById("bttnField").appendChild(cf);
 }
 
 startAni = function(targetId){
   modulePos = getPos(targetId,"bttn");
 
   if(aniFilenames[modulePos] != ''){
     bttn = document.getElementById(targetId);
     bttn.src = "pics/" + aniFilenames[modulePos];
   }
 }
 
 stopAni = function(targetId){
   modulePos = getPos(targetId,"bttn");
 
   bttn = document.getElementById(targetId);
   bttn.src = "pics/" + picFilenames[modulePos];
 }
 
diff --git a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/mitkworkbenchwelcomeview.html b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/mitkworkbenchwelcomeview.html
index eb16e88264..1db8a05d1d 100644
--- a/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/mitkworkbenchwelcomeview.html
+++ b/Plugins/org.mitk.gui.qt.extapplication/resources/welcome/mitkworkbenchwelcomeview.html
@@ -1,37 +1,36 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>MITK Workbench</title>
     <link rel="stylesheet" type="text/css" href="style.css">
   <script language="javascript" src="function.js"></script>
   </head>
 
   <body onload="createButtons()" oncontextmenu="return false;">
 
     <div id="screen">
 
       <!-- Welcome headline and introduction -->
       <div id="welcome">
 
         <h1>Welcome to MITK Workbench!</h1>
 
         <!-- PopUps with module description generated by js are placed in here -->
         <div id="popupAnchor"></div>
 
         <div id="welcomeText">
-          This application was developed at the German Cancer Research Center (DKFZ). The software is developed on the basis of the well established, free open source software toolkit The Medical Imaging Interaction Toolkit (MITK). For additional information check the help pages or our website www.mitk.org.
-<br/><br/><b>Instructions:</b><br/><br/>
+          This application was developed at the German Cancer Research Center (DKFZ). It is based on the well established, free open source Medical Imaging Interaction Toolkit (MITK). Check the help pages or visit our website for additional information:
         </div>
 
       </div>
 
       <!-- area for module buttons -->
       <div id="bttnField">
         <!-- Buttons created by js-fucntion are placed in here -->
       </div>
 
     </div>
   </body>
 </html>
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/Manual.dox
index 116b47b88d..d80a8bc5dc 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/Manual.dox
@@ -1,12 +1,12 @@
 /**
 \page org_mitk_gui_qt_igtexample IGT Examples
 
-This bundle includes views with examples and help applications for IGT. The different views are described on the pages below:
+This plugin includes views with examples and help applications for IGT. The different views are described on the pages below:
 
 <ul>
 <li> \subpage org_igttrackinglab
 <li> \subpage org_imageguidedtherapytutorial
 </ul>
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/Manual.dox
index 6ac68844cb..08bbb387ff 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/Manual.dox
@@ -1,15 +1,15 @@
 /**
 \page org_mitk_gui_qt_igttracking IGT Tracking
 
-This bundle offers basic tracking functionalities. This includes connecting to a tracking system, logging and recording of tracking data, managing tracking tools and playing recorded tracking data.
+This plugin offers basic tracking functionalities. This includes connecting to a tracking system, logging and recording of tracking data, managing tracking tools and playing recorded tracking data.
 
-The bundle includes different views, which are described in different pages in detail:
+The plugin includes different views, which are described in different pages in detail:
 
 <ul>
 <li> \subpage org_mitk_views_igttrackingtoolbox : Allows for connecting to a tracking system and logging/recording of the tracked data.
 <li> \subpage org_mitk_views_igtnavigationtoolmanager : Navigation Tool Manager: This view offers functionality to manage tool storages. Each tool storage holds a preconfigured tool collection. Once saved you can load a tool storage in the Tracking Toolbox and don't need to add every tool seperately.
 <li> \subpage org_mitk_views_navigationdataplayer : Navigation Data Player: Plays navigation data which was recorded with the Tracking Toolbox for example.
 </ul>
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox
index 2253f1917f..0068963460 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox
@@ -1,47 +1,47 @@
 /**
 
 \page org_mitk_views_igtnavigationtoolmanager The MITK-IGT Navigation Tool Manager
 
 \image html iconNavigationToolManager.png "Icon of the Module"
 
 \section QmitkMITKIGTNavigationToolManager Introduction
 
-This bundle allows for creating and editing NavigationToolStorages. These storages contains naviagtion tools of a tracking device, can be saved permanently and used later for any other IGT application.
+This view allows for creating and editing NavigationToolStorages. These storages contains naviagtion tools of a tracking device, can be saved permanently and used later for any other IGT application.
 
 Available sections:
   - \ref QmitkMITKIGTNavigationToolManager
   - \ref QmitkMITKIGTNavigationToolManagerToolOverview
   - \ref QmitkMITKIGTNavigationToolManagerManagingNavigationToolStorage
   - \ref QmitkMITKIGTNavigationToolManagerAddingEditingNavigationTools
 
 \section QmitkMITKIGTNavigationToolManagerToolOverview Navigation Tools Overview
 
 A navigation tool of MITK-IGT represents a tracking tool (e.g. an emt sensor or an optically tracked tool) and it's corresponding data, like it's name and it's surface. A navigation tool is a generalized container for any trackable object in combination with it's additional information. Every navigation tool has different properties which are:
 
 <ul>
 <li> Name
 <li> Unique identifier
 <li> Tool definition file
 <li> Serial number
 <li> Surface for visualization
 <li> Type of tracking device
 <li> Type of the tool
 </ul>
 
-Note that not all properties are needed for all types of tools. A tool definition file, for example, is only needed by optical tracking tools (e.g. a .rom file for Polaris or a toolfile for the MicronTracker). A tool associated with the aurora system is alwalys identified by it's serial number. You can also detect Aurora tools automatically with the TrackingToolbox bundle and edit the automatically detected tool storage later with this bundle. 
+Note that not all properties are needed for all types of tools. A tool definition file, for example, is only needed by optical tracking tools (e.g. a .rom file for Polaris or a toolfile for the MicronTracker). A tool associated with the aurora system is alwalys identified by it's serial number. You can also detect Aurora tools automatically with the TrackingToolbox view and edit the automatically detected tool storage later with this view. 
 
 \section QmitkMITKIGTNavigationToolManagerManagingNavigationToolStorage Managing Navigation Tool Storage
 
 In order to create a new storage container, or edit an existing one, you can use the buttons "add", "edit" and "delete" to manage the contained navigation tools. If you click "edit" or "delete" the operation is applied on the currently selected tool, as shown in the screenshot below. If you want to create a new storage container, just start adding tools when you start the program and save the storage container. To edit an existing tool storage container click "load" and add/edit/delete tools.
 
 \image html NavigationToolManagemantStartScreen.png "Screenshot of the main view of NavigationToolManagent"
 
 \section QmitkMITKIGTNavigationToolManagerAddingEditingNavigationTools Adding / Editing Navigation Tools
 
 If you add or edit a navigation tool, an input mask, as shown in the screenshot below, appears. The tool identifier is filled automatically, if you change it, remember that it is unique in the current storage. Also, choose a valid surface for every tool, this is nessesary for correct tool visualization. The other information depends on the tracking system type. So choose a tool file for the Polaris or the MicronTracker system and type in a serial number for the Aurora system. Two identical tools with the same serial number are also possible, they are assigned by the order in which they are attached to the device. As long as they also have the same surface, this should not be a problem.
 
 The tool type is additional information which is not needed by the tracking device but might be needed by further IGT applications.
 
 \image html NavigationToolManagementAddTool.png "Screenshot of add/edit navigation tool screen"
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox
index c6d911fe51..0d1c66231c 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox
@@ -1,64 +1,64 @@
 /**
 
 \page org_mitk_views_igttrackingtoolbox The MITK-IGT Tracking Toolbox
 
 \image html iconTrackingToolbox.png "Icon of the module"
 
 Available sections:
   - \ref QmitkMITKIGTTrackingToolboxIntroduction
   - \ref QmitkMITKIGTTrackingToolboxWorkflow
   - \ref QmitkMITKIGTTrackingToolboxConnecting
   - \ref QmitkMITKIGTTrackingToolboxLoadingTools
   - \ref QmitkMITKIGTTrackingToolboxAutoDetection
   - \ref QmitkMITKIGTTrackingToolboxStartTracking
   - \ref QmitkMITKIGTTrackingToolboxLogging
   - \ref QmitkMITKIGTTrackingOptions
 
 \section QmitkMITKIGTTrackingToolboxIntroduction Introduction
 
-The MITK-IGT Tracking Toolbox is a bundle which allows you to connect to a tracking device, track and visualize navigation tools and write the tracked data into a log file. Currently the devices Polaris, Aurora (both Northern Digital Inc. (NDI); Waterloo, Ontario, Canada) and MicronTracker (Claron Technology, Inc.; Toronto, Ontario, Canada) are supported. The MicroBird family (Ascension Technology Corporation, Inc.; Burlington, USA) will hopefully follow soon since it is already supported by the tracking layer of IGT. The logging feature of the Tracking Toolbox supports logging in XML or CSV format.
+The MITK-IGT Tracking Toolbox is a view which allows you to connect to a tracking device, track and visualize navigation tools and write the tracked data into a log file. Currently the devices Polaris, Aurora (both Northern Digital Inc. (NDI); Waterloo, Ontario, Canada) and MicronTracker (Claron Technology, Inc.; Toronto, Ontario, Canada) are supported. The MicroBird family (Ascension Technology Corporation, Inc.; Burlington, USA) will hopefully follow soon since it is already supported by the tracking layer of IGT. The logging feature of the Tracking Toolbox supports logging in XML or CSV format.
 
 \image html screenshot_mitk.png "MITK Screenshot with the TrackingToolbox activated"
 
 \section QmitkMITKIGTTrackingToolboxWorkflow General workflow Introduction
 
 A general Workflow with the Tracking Toolbox may be:
 
 <ul>
 <li> Configuration of a tracking device
 <li> Loading a toolfile which holds tool definitions
 <li> Start tracking
 <li> Logging tracked data
 </ul>
 
 \section QmitkMITKIGTTrackingToolboxConnecting Tracking Device Configuration
 
 The tracking device can be specified in the tracking device configuration section located in the upper area of the tracking tab. As shown in the screenshot below, you choose your tracking device in the drop down menu. If you use a tracking system connected to a serial port, like Aurora or Polaris, you then need to specifiy the serial port. In case of the MicronTracker you only need to ensure that all drivers are installed correctly and integrated into MITK. If you want to check the connection, press "test connection". The results are displayed in the small black box on the right.
 
 \image html configurationWidget.png "Tracking Device Configuration"
 
 \section QmitkMITKIGTTrackingToolboxLoadingTools Loading tools
 
-To load tools which can be tracked you need a predefined tracking tool storage. If you use the Aurora system you also have the possibility to automatically detect the connected tools. In this case a tracking tool storage is created by the software (see section below). Otherwise you can use the MITK bundle NavigationToolManager to define a navigation tool storage. There you can create navigation tools with the corresponding toolfiles, visualization surfaces and so on. Please see NavigationToolManager manual for more details.
+To load tools which can be tracked you need a predefined tracking tool storage. If you use the Aurora system you also have the possibility to automatically detect the connected tools. In this case a tracking tool storage is created by the software (see section below). Otherwise you can use the MITK view NavigationToolManager to define a navigation tool storage. There you can create navigation tools with the corresponding toolfiles, visualization surfaces and so on. Please see NavigationToolManager manual for more details.
 
 Navigation tool storages can be loaded by pressing the button "Load Tools". Please ensure that the tracking device type of the tools matches the chosen tracking device, otherwise you will get an error message if you try to start tracking. All loaded tools will then be displayed in grey as shown in the screenshot below. If you start tracking they will become green if the tools were found and red if they were not found inside the tracking volume.
 
 \image html trackingToolsWidget.png "Tracking Tools"
 
 \section QmitkMITKIGTTrackingToolboxAutoDetection Auto detection of tools (only Aurora)
 
 If the Aurora tracking system is used, a button "Auto Detection" appears. If you press this button the software connects to the system and automatically detects all connected tools. You will then be asked whether you want to save the detected tools as a tool storage to the hard drive. You might want to do this if you want to use or modify this tool storage later. In the automatically detected tool storage the tools are named AutoDetectedTools1, AutoDetectedTools2, and so on. Small spheres are used as tool surfaces. After autodetection the detected tools are loaded automatically even if you did not save them.
 
 \section QmitkMITKIGTTrackingToolboxStartTracking Start/stop tracking
 
 Tracking can simply be started by pressing "Start Tracking". Note that options may not be changed during tracking. Once tracking has started the tracking volume (only if the option is on) and the tools are visualized in the 3D view of MITK.
 
 \section QmitkMITKIGTTrackingToolboxLogging Logging features
 
 If your device is tracking, you are able to log the tracking data by using the logging tab. You first must define a file name. You can then choose whether you want comma seperated (csv) or xml format. Press "Start Logging" to start logging. You can also limit the number of logged frames, which will cause the logging to stop automatically after the given number.
 
 \section QmitkMITKIGTTrackingOptions Options
 
 In the options tab you can enable or disable the visualization of the tracking volume and of the tool quaternions. If enabled, the tool quaternions are shown in the tool information. You can also define the update rate of the tracking data. The update rate should not be set higher than the update rate of the tracking system.
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropperUserManual.dox b/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropperUserManual.dox
index 58b7015c0e..26abe156ce 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropperUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropperUserManual.dox
@@ -1,41 +1,41 @@
 /**
-\page org_mitk_views_imagecropper The Image Cropper Module
+\page org_mitk_views_imagecropper The Image Cropper Plugin
 
-\image html icon.png "Icon of the Module"
+\image html icon.png "Icon of the Plugin"
 
 Available sections:
   - \ref QmitkImageCropperUserManualOverview 
   - \ref QmitkImageCropperUserManualFeatures 
   - \ref QmitkImageCropperUserManualUsage 
   - \ref QmitkImageCropperUserManualTroubleshooting
 
 \section QmitkImageCropperUserManualOverview Overview
 
 ImageCropper is a functionality which allows the user to manually crop an image by means of a bounding box. The functionality does not create a new image, it only hides parts of the original image.
 
 \section QmitkImageCropperUserManualFeatures Features
 
 - Crop a selected image using a bounding box.
 - Set the border voxels to a specific user defined value after cropping.
 
 
 
 \section QmitkImageCropperUserManualUsage Usage
 First select from the drop down menu the image to crop. The three 2D widgets show yellow rectangles representing the bounding box in each plane (axial, sagital, coronal), the lower right 3D widget shows the entire volume of the bounding box.\n
 
 - To change the <b>size</b> of bounding box press <i> control + right click </i> and move the cursor up/down or left/right in one of the three 2D views.\n
 - To change the <b>orientation</b> of the bounding box press <i> control + middle click </i> and move the cursor up/down or left/right in one of the three 2D views.\n
 - To <b>move</b> the bounding box press <i> control + left click </i> and move the cursor to the wanted position in one of the three 2D views.\n
 
 
 To show the result press the [crop] button.\n
 To crop the image again press the [New bounding box!] button.\n\n
 
 All actions can be undone by using the global undo function (Ctrl+Z).\n
 
 To set the border voxels to a specific value after cropping the image, activate the corresponding checkbox and choose a gray value.
 
 \section QmitkImageCropperUserManualTroubleshooting Troubleshooting
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox
index 95b83862ae..f3a1131c37 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox
@@ -1,44 +1,44 @@
 /**
-\page org_mitk_views_imagestatistics The Image Statistics Module
+\page org_mitk_views_imagestatistics The Image Statistics View
 
-\image html ImageStatistic_48.png "Icon of the Module"
+\image html ImageStatistic_48.png "Icon of the View"
 
 \section QmitkImageStatisticsUserManualSummary Summary
 
-This module provides an easy interface to quickly compute some features of a whole image or a region of interest.
+This view provides an easy interface to quickly compute some features of a whole image or a region of interest.
 
-This document will tell you how to use this module, but it is assumed that you already know how to use MITK in general.
+This document will tell you how to use this view, but it is assumed that you already know how to use MITK in general.
 
 Please see \ref QmitkImageStatisticsUserManualDetails for more detailed information on usage and supported filters.
-If you encounter problems using the module, please have a look at the \ref QmitkImageStatisticsUserManualTrouble page.
+If you encounter problems using the view, please have a look at the \ref QmitkImageStatisticsUserManualTrouble page.
 
 \section QmitkImageStatisticsUserManualDetails Details
 
 Manual sections:
 
 - \ref QmitkImageStatisticsUserManualOverview 
 - \ref QmitkImageStatisticsUserManualUsage
 - \ref QmitkImageStatisticsUserManualTrouble
 
 \section QmitkImageStatisticsUserManualOverview Overview
 
-This module provides an easy interface to quickly compute some features of a whole image or a region of interest.
+This view provides an easy interface to quickly compute some features of a whole image or a region of interest.
 
 \image html Screenshot1.png "The interface"
 
 \section QmitkImageStatisticsUserManualUsage Usage
 
-After selection of an image or a binary mask of an image in the datamanader, the Image Statistics module shows some statistical information. If a mask is selected, the name of the mask and the name of the image, to which the mask is applied, are shown at the top.
+After selection of an image or a binary mask of an image in the datamanader, the Image Statistics view shows some statistical information. If a mask is selected, the name of the mask and the name of the image, to which the mask is applied, are shown at the top.
 
 Below it is the statistics window which displays the calculated statistical features (such as mean, standard deviation...) and the histogram.
 
-At the bottom of the module are two buttons. They copy their respective data in csv format to the clipboard.
+At the bottom of the view are two buttons. They copy their respective data in csv format to the clipboard.
 
 \section QmitkImageStatisticsUserManualTrouble Troubleshooting
 
 No known problems.
 
 <B>All other problems.</B><BR>
 Please report to the MITK mailing list.
 See http://www.mitk.org/wiki/Mailinglist on how to do this.
 */
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 ad3e18a4d6..c990dbef5a 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
@@ -1,134 +1,134 @@
 /**
-\page org_mitk_views_measurement The Measurement Module
+\page org_mitk_views_measurement The Measurement View
 
-\image html Measurement_48.png "Icon of the Module"
+\image html Measurement_48.png "Icon of the View"
 
 \section QmitkMeasurementUserManualOverview Overview
 
-The Measurement module enables the user to interact with 2D images or single slices of 3D image stacks and planar figure data types. It allows to measure distances, angels, pathes and several geometric figures on a dataset. 
+The Measurement view enables the user to interact with 2D images or single slices of 3D image stacks and planar figure data types. It allows to measure distances, angels, pathes and several geometric figures on a dataset. 
 
 Available Sections:
 - \ref QmitkMeasurementUserManualOverview
 - \ref QmitkMeasurementUserManualFeatures
   - \ref SubOne
   - \ref SubTwo
   - \ref SubThree
   - \ref SubFour
   - \ref SubFive
   - \ref SubSix
   - \ref SubSeven
 - \ref QmitkMeasurementUserManualUsage
   - \ref One
   - \ref Two
   - \ref Three
   - \ref Four
 
-The workflow to use this module is:
+The workflow to use this view is:
 
 \image html Workflow.png
 
-The workflow is repeatedly useable with the same or different measurement figures, which are correlated to the choosen image and can be saved together with it for future use. On pressing the Measurement icon (see picture below the page title) in the view button line the basic appearance of the bundle is as follws.
+The workflow is repeatedly useable with the same or different measurement figures, which are correlated to the choosen image and can be saved together with it for future use. On pressing the Measurement icon (see picture below the page title) in the view button line the basic appearance of the view is as follws.
 
 \image html Basic_Screen_edited.JPG
 
-The standard working plane is "Axial" but the other standard viewplanes ("Saggital" and "Coronal") are also valid for measurements. To swap between the view planes refer to 3M Application Bundle User Manual.
+The standard working plane is "Axial" but the other standard viewplanes ("Saggital" and "Coronal") are also valid for measurements. To swap between the view planes refer to the application user manual.
 
 \section QmitkMeasurementUserManualFeatures Features
 
-The bundle as it is depicted below offers the following features in the order of apperance on the image from top to bottom: 
+The view as it is depicted below offers the following features in the order of apperance on the image from top to bottom: 
 \image html Measurement_View.JPG
 The first information is the selected image's name (here: DICOM-MRI-Image) followed by the measurement figures button line with the seven measurement figures. From left to right the buttons are connected with the following functions:
 
 \subsection SubOne Draw Line
 Draws a line between two set points and returns the distance between these points.
 
 \subsection SubTwo Draw Path
 Draws a path between several set points (two and more) and calculates the circumference, that is all line's length summed up. Add the final point by double left click.
 
 \subsection SubThree Draw Angle
 Draws two lines from three set points connected in the second set point and returns the inner angle at the second point. 
 
 \subsection SubFour Draw Four Point Angle
 Draws two lines that may but must not intersect from four set points. The returned angle is the one depicted in the icon.
 
 \subsection SubFive Draw Circle
 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.
 
 \subsection SubSix Draw Rectangle
 Draws a rectangle by setting two points at the opposing edges of the rectangle starting with the upper left edge. The measured values are the circumference and the included area. 
 
 \subsection SubSeven Draw Polygon
 Draws a polygon by setting three or more points. The measured values are the circumference and the included area. Add the final point by double left click.
 
 Below the buttonline the statistics window is situated, it displays the results of the actual measurements from the selected measurement figures. The content of the statistics window can be copied to the clipboard with the correspondig button for further use in a table calculation programm (e.g. Open Office Calc etc.). 
 
 \image html  Image_processed.JPG
 
-The last row contains again a button line to swap from the measurement bundle (activated in the image) to other supported MITK 3M3 bundles.
+The last row contains again a button line to swap from the measurement perspective (activated in the image) to other supported MITK perspectives.
   
 \section QmitkMeasurementUserManualUsage Usage
 
 This Section is subdivided into four subsections:
 <ol>
     <li><b>Add an image</b>
     <li><b>Work with measurement figures</b>
     <li><b>Save the image with measurement information</b>
   <li><b>Remove measurement figures or image</b>
 </ol>
 
 Let's start with subsection 1
 \subsection One   Add an image
 
 There are two possible ways to add an image to the programm. One is to grap the image with left mouse click from your prefered file browser and simply drag&drop it to the View Plane field. The other way is to use the 
 \image html OpenButton.png
 button in the upper left corner of the application. A dialog window appears showing the file tree of the computer. Navigate to the wanted file and select it with the left mouse click. Afterwards just use the dialog's open button.  
 
 The wanted image appears in the View Plane and in the Data Manager the images name appears as a new tree node. Now the image is loaded it can be adjusted in the usual way ( zoom in/out: right mouse button + moving the mouse up and down, moving the image: press mouse wheel and move the mouse to the wished direction, scroll through the slices( only on 3D images): scroll mouse wheel up and down).
 
 \image html Image_Loaded_Screen.JPG
 
 After the image is loaded the image's name appears in the Data Manager. By left-clicking on the image name the buttonline becomes activated. 
 
 \subsection Two Work with measurement figures
-The measurement module comes with seven measurement figures(see picture below), that can be applied to the images. 
+The measurement view comes with seven measurement figures(see picture below), that can be applied to the images. 
 \image html MeasurementFigureButtonline.jpg
 The results of the measurement with each of these figures is shown in the statistics window and in the lower right corner of the view plane. 
 \image html Image_processed_Screen.JPG
 When applying more then one measurement figure to the image the actual measurement figure is depicted in red and the displayed values belong to this measurement figure. All measurement figures become part of the Data Manager as a node of the image tree.
 
 \subsection Three Save the image with measurement information
 After applying the wanted measurement figures the entire scene consisting of the image and the measurement figures can be saved for future use. Therefore just click the right mouse button when over the image item in the Data Manager and choose the item "Save" in the opening item list. Following to that a save dialog appears where the path to the save folder can be set. Afterwards just accept your choice with the save button.
 
 \subsection Four Remove measurement figures or image
 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 left-click on it or if several items wanted to be removed left click on all wanted by simultaneously holding the ctrl-button pressed.
 
 For more detailed usage of the save/remove functionality refer to the Data Manager User Manual.
 
 <!-- <ul>
   <li> The Measurement Module is able to measure:
   <ul>
     <li> Distances between two points
     <li> Angles between two lines (defined by three points) 
     <li> Distances along a path 
     </ul>
 </ul>
     
 \section QmitkMeasurementUserManualUsage Usage
 To use the Measurement Module, at first a data set must be loaded. That can be done by drag & drop.
 Choose the measurement method you need by pressing the according button. 
 <ul>
   <li>Points can be set by "shift-clicking" on the place in the data set. 
   <li>Remove points by pressing the del-button on your keyboard. 
   <li>You can mark a point by clickon it with the cursor and move it while the mouse button is still pressed. 
 </ul>
 What the different modes mean and how to use them:
 <ul>
   <li> a) Distances: To measure the distance between two points, you have to set two points. The distance will be displayed on the line between the points.
   <li> b) Angles: Angles can be measured between two lines. For that you have to set three points. The angle will be displayed between the two lines. 
   <li> c) Path: Distances and angles along a path can be measured by setting at least two (for distance) or three (for angles) or more (for longer pathes) points. The distance and the angles for each part will be displayed next to the path.
 </ul>
 
 \image html MeasurementGUI.png Graphical User Interface of Measurement -->
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox
index 291d8d2334..e1fb8f97b2 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox
@@ -1,12 +1,12 @@
 /**
-\page org_mitk_gui_qt_measurementtoolbox The Measurement Toolbox Bundle
+\page org_mitk_gui_qt_measurementtoolbox The Measurement Toolbox Plugin
 
 \section QmitkmeasurementToolbox Manual 
 
-This bundle contains all views that provide measurement and statistics functionality.
+This plugin contains all views that provide measurement and statistics functionality.
 
 <ul>
   <li> \subpage org_mitk_views_measurement
   <li> \subpage org_mitk_views_imagestatistics
 </ul>
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.meshdecimation/documentation/Manual/meshdecimation-manual.dox b/Plugins/org.mitk.gui.qt.meshdecimation/documentation/Manual/meshdecimation-manual.dox
index 43367b70d1..5cdc4fafa6 100644
--- a/Plugins/org.mitk.gui.qt.meshdecimation/documentation/Manual/meshdecimation-manual.dox
+++ b/Plugins/org.mitk.gui.qt.meshdecimation/documentation/Manual/meshdecimation-manual.dox
@@ -1,33 +1,33 @@
 /**
 
-\page org_mitk_views_meshdecimation The Mesh Decimation Module
+\page org_mitk_views_meshdecimation The Mesh Decimation Plugin
 
-\image html meshdecimation.png "Icon of the Module"
+\image html meshdecimation.png "Icon of the Plugin"
 
 Available sections:
   - \ref meshdecimationOverview 
   - \ref meshdecimationFeatures 
   - \ref meshdecimationUsage 
 
 \section meshdecimationOverview Overview
 
 MeshDecimation is a user friendly tool to decimate a MITK surface.
 
 \section meshdecimationFeatures Features
 
-The module offers two basic procedures to decimate surfaces: One that reduces a surface with a possible loss of topology (quality), but with a garuanteed reduction rate that is expressed in terms of percent of the original mesh. The other variant preserves the topology and stops decimating when it detects heavy topological changes.   
+The view offers two basic procedures to decimate surfaces: One that reduces a surface with a possible loss of topology (quality), but with a garuanteed reduction rate that is expressed in terms of percent of the original mesh. The other variant preserves the topology and stops decimating when it detects heavy topological changes.   
  
 \section meshdecimationUsage Usage
 
-\image html meshdecimation-ui.png "The user interface of the Mesh Decimation Module"
+\image html meshdecimation-ui.png "The user interface of the Mesh Decimation View"
 
-The usage of the module should be straightforward, as shown in the screenshot. To decimate a MITK surface do the following:
+The usage of the view should be straightforward, as shown in the screenshot. To decimate a MITK surface do the following:
 - Select a surface in the datamanager
 - Enter a target reduction rate
 - Select a decimation method (\ref meshdecimationFeatures)
 - Press the "Decimate" button
 - Repeat the process until you are satisfied with the decimation
 - Save the surface to disk
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMakerUserManual.dox b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMakerUserManual.dox
index 24068b877c..602f4243c5 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMakerUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMakerUserManual.dox
@@ -1,45 +1,45 @@
 /**
 
-\page org_mitk_views_moviemaker The Movie Maker Module
+\page org_mitk_views_moviemaker The Movie Maker View
 
-\image html icon.png "Icon of the Module"
+\image html icon.png "Icon of the View"
 
 Available sections:
   - \ref QmitkMovieMakerUserManualOverview 
   - \ref QmitkMovieMakerUserManualFeatures 
   - \ref QmitkMovieMakerUserManualUsage 
 
 \section QmitkMovieMakerUserManualOverview Overview
 
 MovieMaker is a functionality for easily creating fancy movies from scenes displayed in MITK widgets.
 It is also possible to slide through your data, automatically rotate 3D scenes and take screenshots of widgets.
 
 \section QmitkMovieMakerUserManualFeatures Features
 
  The Movie Maker allows you to create movies and screenshots from within MITK. It can automatically scroll thorugh timesteps and slices while recording a movie. This way, you can record visualizations like a beating heart or a rotating skull.
  
 \section QmitkMovieMakerUserManualUsage Usage
 
 \image html QmitkMovieMakerControlArea.png "A view of the command area of QmitkMovieMaker"
 
 \subsection QmitkMovieMakerUserManualWindowSelection Window selection
 With the first two drop down boxes, you can choose which window you want to step through and which window you want to record in. Left clicking inside a window will set both drop down boxes to that window, but you can choose different windows for stepping and recording.
 
 The first drop down box defines the window along which slices will be stepped through if stepping is set to spatial (see below). The second denotes the window from which the content will be recorded.
 
 \subsection QmitkMovieMakerUserManualRecordingOptions Recording Options
 
 The slider can be used to step through the slices manually while not recording. Start and stop control a preview of what a video would look like.
 
 The buttons in the bottom part of this section can be used to create movies (windows only) or screenshots. Clicking opens a file %dialog where a name can be selected. After confirmation, a screenshot or movie is created according to the playing options.
 
 \subsection QmitkMovieMakerUserManualPlayingOptions Playing Options
 
 The first section controls whether the movie steps through slices (if a 2D view is selected), rotate the shown scene (if a 3D view is selected), or step through time steps (if set to temporal and a time resolved dataset is selected). If set to combined, a combination of both above options is used, with their speed relation set via the S/T Relation Spinbox.
 
 In the second section the direction of stepping can be set. Options are: Forward, backward and Ping-Pong, which is back-and-forth.The stepping speed can be set via the spinbox(total time in seconds).
 
 Although stepping speed is a total time in sec., this can not always be achieved. As a minimal frame rate of 25 fps is assumed to provide smooth movies, a dataset with only 25 slices will always be stepped through in 1 sec or faster.
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMakerManual.dox b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMakerManual.dox
index 8536d9f771..688b614a55 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMakerManual.dox
+++ b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMakerManual.dox
@@ -1,19 +1,19 @@
 /**
 \page org_mitk_views_screenshotmaker The Screenshot Maker
 
-This module provides the functionality to create and save screenshots of the data.
+This view provides the functionality to create and save screenshots of the data.
 
 Available sections:
   - \ref QmitkScreenshotMakerUserManualUse
 
 \image html screenshot_maker_interface.png The Screenshot Maker User Interface
 
 \section QmitkScreenshotMakerUserManualUse Usage
 
 The first section offers the option of creating a screenshot of the last activated render window (thus the one, which was last clicked into). Upon clicking the button, the Screenshot Maker asks for a filename in which the screenshot is to be stored. The multiplanar Screenshot button asks for a folder, where screenshots of the three 2D views will be stored with default names.
 
 The high resolution screenshot section works the same as the simple screenshot section, aside from the fact, that the user can choose a magnification factor.
 
 In the option section one can rotate the camera in the 3D view by using the buttons. Furthermore one can choose the background colour for the screenshots, default is black.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteractionUserManual.dox b/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteractionUserManual.dox
index 56d10b37a8..5151fea9ac 100644
--- a/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteractionUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteractionUserManual.dox
@@ -1,38 +1,38 @@
 /**
-\page org_mitk_views_pointsetinteraction The Point Set Interaction Module
+\page org_mitk_views_pointsetinteraction The Point Set Interaction View
 
-\image html pointset_interaction.png "Icon of the Module"
+\image html pointset_interaction.png "Icon of the View"
 
 Available sections:
   - \ref QmitkPointSetInteractionUserManualOverview 
   - \ref QmitkPointSetInteractionUserManualDetails 
 
 \section QmitkPointSetInteractionUserManualOverview Overview
 
 This functionality allows you to define multiple sets of points, to fill them with points and to save them in so called PointSets.
 
 \image html QmitkPointSetInteraction.png "MITK with the QmitkPointSetInteraction functionality"
 
 This document will tell you how to use this functionality, but it is assumed that you already know how to navigate through the slices of an image using the
 four window view. Please read the application manual for more information.
 
 \section QmitkPointSetInteractionUserManualDetails Details
 
 First of all you have to select a PointSet to use this functionality. Therefore, you have to select the point set in the data manager. If there are currently no point sets in the data tree, you have to first add a new point set to the data tree. This is done by clicking the "Add pointset..." 
 button.
 
 \image html AddPointSet.png "The Add pointset... dialog"
 
 In the pop-up dialog, you have to specify a name for the new point set. This is also the node for the new data tree item.
 
 \image html CurrentPointSetArea.png "The Current pointset area"
 
 The "Current pointset" area contains a list of points. Within this area, all points for the current point set node are listed. To set points you have to toggle the "Set Points"  button, the leftmost of the four buttons on the bottom of the view. Points can be defined by performing a left mouse button click while holding the "Shift"-key pressed in the four window view. 
 
 To erase all points from the list press the next button. The user is prompted to confirm the decision. If you want to delete only a single point, left click on it in the list and then press delete on your keyboard. 
 
 With the third button, a previously saved point set can be loaded and all of its points are shown in the list and the four window view. The user is prompted to select the file to be loaded. The file extension is ".mps". On the right of this button is the save button. With this function the entire point set can be saved to the harddrive. The user is prompted to select a filename. Pointsets are saved in XML fileformat but have to have a ".mps" file extension. 
 
 You can select points in the render window, if the "Set Points" button is toggled, with a left mouse button click on them. If you keep the mouse button pressed, you can move the points by moving the mouse and then releasing the mouse button. With the delete key you can remove the selected points. 
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkDeformableRegistrationUserManual.dox b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkDeformableRegistrationUserManual.dox
index 9e88fa396e..fd11c761dc 100644
--- a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkDeformableRegistrationUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkDeformableRegistrationUserManual.dox
@@ -1,52 +1,52 @@
 /**
-\page org_mitk_views_deformableregistration The Deformable Image Registration Module
+\page org_mitk_views_deformableregistration The Deformable Image Registration View
 
 Available sections:
   - \ref DeformableRegistrationUserManualOverview
   - \ref DeformableRegistrationUserManualDetails
 
 \section DeformableRegistrationUserManualOverview Overview
 
-This module allows you to register 2D as well as 3D images in a deformable manner. Register means to align two images, so that they become as similar as
+This view allows you to register 2D as well as 3D images in a deformable manner. Register means to align two images, so that they become as similar as
 possible. Registration results will directly be applied to the Moving Image.
 
-\image html QmitkDeformableRegistration_small.png "MITK with the DeformableRegistration module"
+\image html QmitkDeformableRegistration_small.png "MITK with the DeformableRegistration view"
 
-This document will tell you how to use this module, but it is assumed that you already know how to navigate through the slices of an image using the
+This document will tell you how to use this view, but it is assumed that you already know how to navigate through the slices of an image using the
 multi-widget.
 
 \section DeformableRegistrationUserManualDetails Details
 
 First of all you have to open the data sets which you want to register and select them in the Data Manager. You have to select exactly 2 images for registration. The image which was selected 
 first will become the fixed image, the other one the moving image. The two selected images will remain for registration until exactly two images were selected in the Data Manager again. While 
-there aren't two images for registration a message is viewed on top of the module saying that registration needs two images. If two images are selected the message disappears and the interaction 
+there aren't two images for registration a message is viewed on top of the view saying that registration needs two images. If two images are selected the message disappears and the interaction 
 areas for the fixed and moving data appears. On default only the fixed and moving image are shown in the render windows. If you want to have other images visible you have to set the visibility 
 via the Data Manager. Also if you want to perform a reinit on a specific node or a global reinit for all nodes you have to use the Data Manager.
 
 \image html ImageSelectionDeformable.png "The Image area"
 
 The upper area is the "Image" area, where the selected images are shown. It is used for changing the colour of the images between grey values and red/green as well as for changing the opacity of the moving image.
 To do so, just use the "Moving Image Opacity:" slider. In the "Show Images Red/Green" you can switch the color from both datasets. If you check the box, the fixed dataset will be displayed in redvalues and the
 moving dataset in greenvalues to improve visibility of differences in the datasets. If you uncheck the "Show Images Red/Green" checkbox, 
 both datasets will be displayed in greyvalues.
 
 \image html RegistrationDeformable.png "The Registration area for Demons based registration"
 
 In the "Registration" area you have the choice between different Demonsbased deformable registration algorithms. There are available:
 
 \li <b>Demons Registration</b>
 
 \li <b>Symmetric Forces Demons Registration</b>
 
 For both methods you have to define the same set of parameters. First you have to decide whether you want to perform a histogram matching. This can be done by selecting "Use Histogram Matching". 
 When it is selected the corresponding parameters are enabled and have to be set. These are the "Number of Histogram Levels", "Number of Match Points" and whether to use a "Threshold at Mean 
 Intensity".
 
 For the registration method itself you have to specify the "Number of Iterations" and the "Standard Deviation" within the "Demons Registration" area.
 
 If all this is done, you can perform the registration by clicking the "Calculate Transformation" button. Finally, you will be asked where you want the result image and the resulting deformation field 
 to be saved. Therefore you have to select the folder and enter a filename.
 
 The results will be added in the DataStorage and can be saved in the Data Manager.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkPointBasedRegistrationUserManual.dox b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkPointBasedRegistrationUserManual.dox
index ab8841cd4b..cfc7e3be68 100644
--- a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkPointBasedRegistrationUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkPointBasedRegistrationUserManual.dox
@@ -1,106 +1,106 @@
 /**
-\page org_mitk_views_pointbasedregistration  The Point Based Registration Module
+\page org_mitk_views_pointbasedregistration  The Point Based Registration View
 
-\image html pointBasedIcon.png "Icon of the Module"
+\image html pointBasedIcon.png "Icon of the View"
 
 Available sections:
   - \ref PointBasedRegistrationUserManualOverview 
   - \ref PointBasedRegistrationUserManualDetails 
 
 \section PointBasedRegistrationUserManualOverview Overview
 
-This module allows you to register two datasets in a rigid and deformable manner via corresponding 
+This view allows you to register two datasets in a rigid and deformable manner via corresponding 
 PointSets. Register means to align two datasets, so that they become as similar as possible. 
 Therefore you have to set corresponding points in both datasets, which will be matched. The movement, which has to be 
 performed on the points to align them, will be performed on the moving data as well. The result is shown in the multi-widget. 
 
-\image html PointBasedRegistration_small.png "MITK with the PointBasedRegistration module"
+\image html PointBasedRegistration_small.png "MITK with the PointBasedRegistration view"
 
-This document will tell you how to use this module, but it is assumed that you already know how to navigate through 
+This document will tell you how to use this view, but it is assumed that you already know how to navigate through 
 the slices of a dataset using the multi-widget.
 
 \section PointBasedRegistrationUserManualDetails Details
 
 First of all you have to open the data sets which you want to register and select them in the Data Manager. You have to select exactly 2 images for registration. The image which was selected 
 first will become the fixed image, the other one the moving image. The two selected images will remain for registration until exactly two images were selected in the Data Manager again. While 
-there aren't two images for registration a message is viewed on top of the module saying that registration needs two images. If two images are selected the message disappears and the interaction 
+there aren't two images for registration a message is viewed on top of the view saying that registration needs two images. If two images are selected the message disappears and the interaction 
 areas for the fixed and moving data appears. The upper area is for interaction with the fixed data. Beneath this area is the interaction area for the moving data. On default only the fixed and 
 moving image with their corresponding pointsets are shown in the render windows. If you want to have other images visible you have to set the visibility via the Data Manager. Also if you want to 
 perform a reinit on a specific node or a global reinit for all nodes you have to use the Data Manager.
 
 \image html FixedDataPointBased.png "The Fixed Data area"
 
 The "Fixed Data" area contains a QmitkPointListWidget. Within this widget, all points for the fixed data are listed. The label above this list shows the number of points that are already set. 
 To set points you have to toggle the "Set Points"  button, the leftmost under the QmitkPointListWidget. The views in the QmitkStdMultiWidget were reinitialized to the fixed data. Points can 
 be defined by performing a left click while holding the "Shift"-key pressed in the QmitkStdMultiWidget. You can remove the interactor which listens for left clicks while 
 holding the "Shift"-key pressed by detoggle the "Set Points" button. The next button, "Clear Point Set", is for deleting all specified points from this dataset. The user is prompted to confirm 
 the decision. With the most right button, a previously saved point set can be loaded and all of its points are shown in the QmitkPointListWidget and in the QmitkStdMultiWidget. The user is prompted 
 to select the file to be loaded. The file extension is ".mps". On the left of this button is the save button. With this function all points specified for this dataset and shown in the 
 QmitkPointListWidget are saved to harddisk. The user is prompted to select a filename. Pointsets were saved in XML fileformat but have to have a ".mps" file extension. You can select landmarks 
 in the render window with a left mouse button click on them. If you keep the mouse button pressed you can move the landmark to an other position by moving the mouse and then release the mouse 
 button. With the delete key you can remove the selected landmarks. You can also select landmarks by a double click on a landmark within the QmitkPointListWidget. Using the "Up-Arrow"-button or
 the "F2" key you can easily move a landmark upwards and bring it further downwards by pressing "F3" or using the "Down-Arrow"-button. Thus the landmark number can be changed. 
 The QmitkStdMultiWidget changes its view to show the position of the landmark.
 
 \image html MovingDataPointBased.png "The Moving Data area"
 
 The "Moving Data" area contains a QmitkPointListWidget. Within this widget, all points for the moving data are listed. The label above this list shows the number of points that are already set. 
 To set points you have to toggle the "Set Points"  button, the leftmost under the QmitkPointListWidget. The views in the QmitkStdMultiWidget were reinitialized to the moving data. With the 
 "Opacity:" slider you can change the opacity of the moving dataset. If the slider is leftmost the moving dataset is totally transparent, whereas if it is rightmost the moving dataset is totally 
 opaque. Points can be defined by performing a left click while holding the "Shift"-key pressed in the QmitkStdMultiWidget. You can remove the interactor which listens for left 
 mousebutton click while holding the "Shift"-key pressed by detoggle the "Set Points" button. The next button, "Clear Point Set", is for deleting all specified points from this dataset. The user 
 is prompted to confirm the decision. With the button on your right hand side, a previously saved point set can be loaded and all of its points are shown in the QmitkPointListWidget and in the QmitkStdMultiWidget. 
 The user is prompted to select the file to be loaded. The file extension is ".mps". On the left of this button is the save button. With this function all points specified for this dataset and 
 shown in the QmitkPointListWidget are saved to harddisk. The user is prompted to select a filename. Pointsets were saved in XML fileformat but have to have a ".mps" file extension. You can 
 select landmarks in the render window with a left click on them. If you keep the mouse button pressed you can move the landmark to an other position by moving the mouse and then 
 release the mouse button. With the delete key you can remove the selected landmarks. You can also select landmarks by a double click on a landmark within the QmitkPointListWidget. Using the "Up-Arrow"-button or
 the "F2" key you can easily move a landmark upwards and bring it further downwards by pressing "F3" or using the "Down-Arrow"-button. Thus the landmark number can be changed.The QmitkStdMultiWidget changes its view to show the position of the 
 landmark.
 
 \image html DisplayOptionsPointBased.png "The Display Options area"
 
 In this area you can find the "Show Images Red/Green" checkbox. Here you can switch the color from both datasets. If you check the box, the fixed dataset will be 
 displayed in redvalues and the moving dataset in greenvalues to improve visibility of differences in the datasets. If you uncheck the "Show Images Red/Green" checkbox, both datasets will be 
 displayed in greyvalues.
 
 Before you perform your transformation it is useful to see both images again. Therefore detoggle the "Set Points" button for the fixed data as well as for the moving data.
 
 \image html RegistrationPointBased.png "The Registration area"
 
 The functions concerning the registration are displayed in the "Registration" area. It not only contains the registration method selection and the registration itself but also offers the possibility
 to save, undo or redo the results. Furthermore a display is implemented, which shows you how good the landmarks correspond.
 Those features will be explained in following paragraphs.
 
 Using the "Method"-selector, you can pick one of those transformations: <b>Rigid</b>, <b>Similarity</b>, <b>Affine</b> and <b>LandmarkWarping</b>.
 Depending on which one you chose, an additional specifier, "Use ICP" can be set, which leads to the following possibilities for registration: 
 
 \li <b>Rigid with ICP</b> means only translation and rotation. The order of your landmarks will not be taken into account. E. g. landmark one in the fixed data can be mapped on landmark three in the moving data. You 
 have to set at least one landmark in each dataset to enable the Register button which performs the transformation.
 
 \li <b>Similarity with ICP</b> means only translation, scaling and rotation. The order of your landmarks will not be taken into account. E. g. landmark one in the fixed data can be mapped on landmark three in the 
 moving data. You have to set at least one landmark in each dataset to enable the Register button which performs the transformation.
 
 \li <b>Affine with ICP</b> means only translation, scaling, rotation and shearing. The order of your landmarks will not be taken into account. E. g. landmark one in the fixed data can be mapped on landmark three in 
 the moving data. You have to set at least one landmark in each dataset to enable the Register button which performs the transformation.
 
 \li <b>Rigid</b> means only translation and rotation. The order of your landmarks will be taken into account. E. g. landmark one in the fixed data will be mapped on landmark one in the moving data. You have to set 
 at least one landmark and the same number of landmarks in each dataset to enable the Register button which performs the transformation.
 
 \li <b>Similarity</b> means only translation, scaling and rotation. The order of your landmarks will be taken into account. E. g. landmark one in the fixed data will be mapped on landmark one in the moving data. 
 You have to set at least one landmark and the same number of landmarks in each dataset to enable the Register button which performs the transformation.
 
 \li <b>Affine</b> means only translation, scaling, rotation and shearing. The order of your landmarks will be taken into account. E. g. landmark one in the fixed data will be mapped on landmark one in the moving 
 data. You have to set at least one landmark and the same number of landmarks in each dataset to enable the Register button which performs the transformation.
 
 \li <b>LandmarkWarping</b> means a freeform deformation of the moving image, so that afterwards the landmarks are exactly aligned. The order of your landmarks will be taken into account. 
 E. g. landmark one in the fixed data will be mapped on landmark one in the moving data. You have to set at least one landmark and the same number of landmarks in each dataset to enable the 
 Register button which performs the transformation.
 
 The root mean squares difference between the landmarks will be displayed as number, so that you can check how good the landmarks correspond.
 
 The "Undo Transformation" button becomes enabled after performing a transformation and allows you to undo it. After doing this, the "Redo Transformation" button
 is enabled and lets you redo, the just undone transformation(no calculation  needed)
 
 Saving of the transformed image can be done via the Data Manager.
  
 */
diff --git a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkRigidRegistrationUserManual.dox b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkRigidRegistrationUserManual.dox
index 089cd17e3a..3d0c69fe8a 100644
--- a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkRigidRegistrationUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/QmitkRigidRegistrationUserManual.dox
@@ -1,214 +1,214 @@
 /**
-\page org_mitk_views_rigidregistration The Rigid Registration Module
+\page org_mitk_views_rigidregistration The Rigid Registration View
 
-\image html rigidRegistrationIcon.png "Icon of the Module"
+\image html rigidRegistrationIcon.png "Icon of the View"
 
 Available sections:
   - \ref QmitkRigidRegistrationUserManualOverview 
   - \ref QmitkRigidRegistrationUserManualIssues 
   - \ref QmitkRigidRegistrationUserManualDetails
   - \ref QmitkRigidRegistrationUserManualReferences 
 
 \section QmitkRigidRegistrationUserManualOverview Overview
 
-This module allows you to register 2D as well as 3D images in a rigid manner. If the Moving Image is an image with multiple timesteps you can select one timestep for registration. 
+This view allows you to register 2D as well as 3D images in a rigid manner. If the Moving Image is an image with multiple timesteps you can select one timestep for registration. 
 Register means to align two images, so that they become as similar as possible. Therefore you can select from different transforms, metrics and optimizers. Registration results will 
 directly be applied to the Moving Image. Also binary images as image masks can be used to restrict the metric evaluation only to the masked area.
 
-\image html RigidRegistration_small.png "MITK with the QmitkRigidRegistration module"
+\image html RigidRegistration_small.png "MITK with the QmitkRigidRegistration view"
 
-This document will tell you how to use this module, but it is assumed that you already know how to navigate through the slices of an image using the
+This document will tell you how to use this view, but it is assumed that you already know how to navigate through the slices of an image using the
 multi-widget.
 
 \section QmitkRigidRegistrationUserManualIssues Known Issues
 
 Depending on your system the registration can fail to allocate memory for calculating the gradient image for registration. In this case you can try to select another optimizer which is not based 
 on a gradient image and uncheck the checkbox for "Compute Gradient".
 
 \section QmitkRigidRegistrationUserManualDetails Details
 
 First of all you have to open the data sets which you want to register and select them in the Data Manager. You have to select exactly 2 images for registration. The image which was selected 
 first will become the fixed image, the other one the moving image. The two selected images will remain for registration until exactly two images were selected in the Data Manager again. 
 
 \image html ImageArea.png "The Image area"
 
-While there aren't two images for registration a message is viewed on top of the module saying that registration needs two images. If two images are selected the message disappears and the 
+While there aren't two images for registration a message is viewed on top of the view saying that registration needs two images. If two images are selected the message disappears and the 
 interaction areas for the fixed and moving data appears. If both selected images have a binary image as childnode a selection box appears which allows, when checked, to use the binary images as 
 image mask to restrict the registration on this certain area. If an image has more than one binary image as child, the upper one from the DataManager list is used. If the Moving Image is a 
 dynamic images with several timesteps a slider appears to select a specific timestep for registration. 
 
 On default only the fixed and moving image are shown in the render windows. If you want to have other images visible you have to set the visibility 
 via the Data Manager. Also if you want to perform a reinit on a specific node or a global reinit for all nodes you have to use the Data Manager.
 
 The colour of the images can be changed between grey values and red/green and the opacity of the moving image can be changed.
 With the "Moving Image Opacity:" slider you can change the opacity of the moving dataset. In the "Show Images Red/Green" you can switch the color from both datasets. If you check the box, 
 the fixed dataset will be displayed in red-values and the moving dataset in green-values to improve visibility of differences in the datasets. If you uncheck the "Show Images Red/Green" checkbox, 
 both datasets will be displayed in grey-values.
 
 \image html RegistrationArea.png "The Registration area"
 
 In the "Register" area you can start the registration by clicking the "Calculate Transform" button. The optimizer value for every iteration step is diplayed as LCD number next to the 
 "Optimizer Value:" label. Many of the registration methods can be canceled during their iteration steps by clicking the "Stop Optimization" button. During the calculation, a progress bar 
 indicates the progress of the registration process. The render widgets are updated for every single iteration step, so that the user has the chance to supervise how good the registration 
 process works with the selected methods and parameters. If the registration process does not lead to a sufficient result, it is possible to undo the transformation and restart the registration 
 process with some changes in parameters. The differences in transformation due to the changed parameters can be seen in every iteration step and help the user understand the parameters.
 Also the optimizer value is updated for every single iteration step and shown in the GUI. The optimizer value is an indicator for the misalignment between the two images. The real time 
 visualization of the registration as well as the optimizer value provides the user with information to trace the improvement through the optimization process.
 The "Undo Transformation" button becomes enabled when you have performed an transformation and you can undo the performed transformations. The "Redo Transformation" button becomes enabled when 
 you have performed an undo to redo the transformation without to recalculate it.
 
 \image html ManualRegistrationArea.png "The Manual Registration area"
 
 In the "Manual Registration" area, shown by checking the checkbox Manual Registration, you can manually allign the images by moving sliders for translation and scaling in x-, y- and z-axis as 
 well as for rotation around the x-, y- and z-Axis. Additionally you can automatically allign the image centers with the button "Automatic Allign Image Centers".
 
 \image html Tab2.png "The Advanced Mode tab"
 
 In the "Advanced Mode" tab you can choose a transform, a metric, an optimizer and an interpolator and you have to set the corresponding parameters to specify the registration 
 method you want to perform. With the topmost button you can also load testpresets. These presets contain all parametersets which were saved using the "Save as Testpreset" button. The "Save as 
 Preset" button makes the preset available from the "Automatic Registration" tab. This button should be used when a preset is not intended for finding good parameters anymore but can be used as 
 standard preset.
 
 To show the current transform and its parameters for the registration process, the Transform checkbox has to be checked. Currently, the following transforms are implemented 
 (for detailed information see [1] and [2]):
 
 \li <b>Translation:</b> Transformation by a simple translation for every dimension.
 
 \li <b>Scale:</b> Transformation by a certain scale factor for each dimension.
 
 \li <b>ScaleLogarithmic:</b> Transformation by a certain scale factor for each dimension. The parameter factors are passed as logarithms.
 
 \li <b>Affine:</b> Represents an affine transform composed of rotation, scaling, shearing and translation.
 
 \li <b>FixedCenterOfRotationAffine:</b> Represents an affine transform composed of rotation around a user provided center, scaling, shearing and translation.
 
 \li <b>Rigid3D:</b> Represents a 3D rotation followed by a 3D translation.
 
 \li <b>Euler3D:</b> Represents a rigid rotation in 3D space. That is, a rotation followed by a 3D translation.
 
 \li <b>CenteredEuler3D:</b> Represents a rigid rotation in 3D space around a user provided center. That is, a rotation followed by a 3D translation.
 
 \li <b>QuaternionRigid:</b> Represents a 3D rotation and a 3D translation. The rotation is specified as a quaternion.
 
 \li <b>Versor:</b> Represents a 3D rotation. The rotation is specified by a versor or unit quaternion.
 
 \li <b>VersorRigid3D:</b> Represents a 3D rotation and a 3D translation. The rotation is specified by a versor or unit quaternion.
 
 \li <b>ScaleSkewVersor3D:</b> Represents a 3D translation, scaling, shearing and rotation. The rotation is specified by a versor or unit quaternion.
 
 \li <b>Similarity3D:</b> Represents a 3D rotation, a 3D translation and homogeneous scaling.
 
 \li <b>Rigid2D:</b> Represents a 2D rotation followed by a 2D translation.
 
 \li <b>CenteredRigid2D:</b> Represents a 2D rotation around a user provided center followed by a 2D translation.
 
 \li <b>Euler2D:</b> Represents a 2D rotation and a 2D translation.
 
 \li <b>Similarity2D:</b> Represents a 2D rotation, homogeneous scaling and a 2D translation.
 
 \li <b>CenteredSimilarity2D:</b> Represents a 2D rotation around a user provided center, homogeneous scaling and a 2D translation.
 
 The desired transform can be chosen from a combo box. All parameters defining the selected transform have to be specified within the line edits and checkboxes underneath the transform combo box.
 To show the current metric and its parameters for the registration process, the Metric checkbox has to be checked. Currently, the following metrics are implemented 
 (for detailed information see [1] and [2]):
 
 \li <b>MeanSquares:</b> Computes the mean squared pixel-wise difference in intensity between image A and B.
 
 \li <b>NormalizedCorrelation:</b> Computes pixel-wise cross correlation and normalizes it by the square root of the autocorrelation of the images.
 
 \li <b>GradientDifference:</b> Evaluates the difference in the derivatives of the moving and fixed images.
 
 \li <b>KullbackLeiblerCompareHistogram</b>[3]<b>:</b> Measures the relative entropy between two discrete probability distributions.
 
 \li <b>CorrelationCoefficientHistogram:</b> Computes the cross correlation coefficient between the intensities.
 
 \li <b>MeanSquaresHistogram:</b> The joint histogram of the fixed and the mapped moving image is built first. Then the mean squared pixel-wise difference in intensity between image A and B is 
 calculated.
 
 \li <b>MutualInformationHistogram:</b> Computes the mutual information between image A and image B.
 
 \li <b>NormalizedMutualInformationHistogram:</b> Computes the mutual information between image A and image B.
 
 \li <b>MattesMutualInformation</b>[4, 5]<b>:</b> The method of Mattes et al. is used to compute the mutual information between two images to be registered.
 
 \li <b>MeanReciprocalSquareDifference:</b> Computes pixel-wise differences and adds them after passing them through a bell-shaped function 1 / (1+x^2).
 
 \li <b>MutualInformation</b>[6]<b>:</b> Computes the mutual information between image A and image B.
 
 \li <b>MatchCardinality:</b> Computes cardinality of the set of pixels that match exactly between the moving and fixed images.
 
 \li <b>KappaStatistic</b>[7]<b>:</b> Computes spatial intersection of two binary images.
 
 The desired metric can be chosen from a combo box. All parameters defining the selected metric have to be specified within the line edits and checkboxes underneath the metric combo box.
 To show the current optimizer and its parameters for the registration process, the Optimizer checkbox has to be checked. Currently, the following optimizers are implemented 
 (for detailed information see [1] and [2]):
 
 \li <b>Exhaustive:</b> Fully samples a grid on the parametric space.
 
 \li <b>GradientDescent:</b> A simple gradient descent optimizer.
 
 \li <b>QuaternionRigidTransformGradientDescent:</b> Variant of a gradient descent optimizer.
 
 \li <b>LBFGSB</b>[8, 9]<b>:</b> Limited memory Broyden Fletcher Goldfarb Shannon minimization with simple bounds.
 
 \li <b>OnePlusOneEvolutionary</b>[10]<b>:</b> 1+1 evolutionary strategy.
 
 \li <b>Powell:</b> Implements Powell optimization using Brent line search.
 
 \li <b>FRPR:</b> Fletch-Reeves & Polak-Ribiere optimization using dBrent line search.
 
 \li <b>RegularStepGradientDescent:</b> Variant of a gradient descent optimizer.
 
 \li <b>VersorTransform:</b> Variant of a gradient descent optimizer.
 
 \li <b>Amoeba:</b> Implementation of the Nelder-Meade downhill simplex algorithm.
 
 \li <b>ConjugateGradient:</b> Used to solve unconstrained optimization problems.
 
 \li <b>LBFGS:</b> Limited memory Broyden Fletcher Goldfarb Shannon minimization.
 
 \li <b>SPSA</b>[11]<b>:</b> Based on simultaneous perturbation.
 
 \li <b>VersorRigid3DTransform:</b> Variant of a gradient descent optimizer for the VersorRigid3DTransform parameter space.
 
 The desired optimizer can be chosen from a combo box. All parameters defining the selected optimizer have to be specified within the line edits and checkboxes underneath the optimizer combo box.
 To show the current interpolator for the registration process, just check the Interpolator checkbox. Currently, the following interpolators are implemented 
 (for detailed information see [1] and [2]):
 
 \li <b>Linear:</b> Intensity varies linearly between grid positions.
 
 \li <b>NearestNeighbor:</b> Uses the intensity of the nearest grid position.
 
 You can show and hide the parameters for the selection by checking or unchecking the corresponding area. You can save the current sets of parameters with the "Save as Testpreset" or "Save as 
 Preset" buttons.
 
 \section QmitkRigidRegistrationUserManualReferences References:
 
 1. L. Ibanez, W. Schroeder and K. Ng, The ITK Software Guide, Kitware Inc, New York, 2005.
 
 2. http://www.itk.org/Doxygen/
 
 3. Albert C.S. Chung, William M. Wells III, Alexander Norbash, and W. Eric L. Grimson, Multi-modal Image Registration by Minimising Kullback-Leibler Distance, In Medical Image Computing and 
 Computer-Assisted Intervention - MICCAI 2002, LNCS 2489, pp. 525 - 532.
 
 4. D. Mattes, D. R. Haynor, H. Vesselle, T. Lewellen and W. Eubank, "Nonrigid multimodality image registration", Medical Imaging 2001: Image Processing, 2001, pp. 1609-1620.
 
 5. D. Mattes, D. R. Haynor, H. Vesselle, T. Lewellen and W. Eubank, "PET-CT Image Registration in the Chest Using Free-form Deformations", IEEE Transactions in Medical Imaging. 
 Vol.22, No.1, January 2003, pp.120-128.
 
 6. Viola, P. and Wells III, W. (1997). "Alignment by Maximization of Mutual Information" International Journal of Computer Vision, 24(2):137-154.
 
 7. AP Zijdenbos, BM Dawant, RA Margolin , AC Palmer, Morphometric analysis of white matter lesions in MR images: Method and validation, IEEE Transactions on Medical Imaging, 
 13(4):716-724, Dec. 1994.
 
 8. R. H. Byrd, P. Lu and J. Nocedal. A Limited Memory Algorithm for Bound Constrained Optimization, (1995), SIAM Journal on Scientific and Statistical Computing , 16, 5, pp. 1190-1208.
 
 9. C. Zhu, R. H. Byrd and J. Nocedal. L-BFGS-B: Algorithm 778: L-BFGS-B, FORTRAN routines for large scale bound constrained optimization (1997), ACM Transactions on Mathematical Software, 
 Vol 23, Num. 4, pp. 550 - 560. 
 
 10. Martin Styner, G. Gerig, Christian Brechbuehler, Gabor Szekely, "Parametric estimate of intensity inhomogeneities applied to MRI", IEEE TRANSACTIONS ON MEDICAL IMAGING; 19(3), pp. 153-165,
  2000.
 
 11. Spall, J.C. (1998), "An Overview of the Simultaneous Perturbation Method for Efficient Optimization," Johns Hopkins APL Technical Digest, vol. 19, pp. 482-492.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/RegistrationModuleOverview.dox b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/RegistrationModuleOverview.dox
index 1f43c7a195..64aa225fa7 100644
--- a/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/RegistrationModuleOverview.dox
+++ b/Plugins/org.mitk.gui.qt.registration/documentation/UserManual/RegistrationModuleOverview.dox
@@ -1,14 +1,14 @@
 /**
-\page org_mitk_gui_qt_registration The Registration Modules
+\page org_mitk_gui_qt_registration The Registration Plugin
 
 \section RegistrationModuleOverviewPageOverview Overview
 
-MITK provides several modules for the registration of images.
+MITK provides several views for the registration of images.
 
-\section RegistrationModuleOverviewPageList List of Modules
+\section RegistrationModuleOverviewPageList List of Views
 
   \li \subpage org_mitk_views_deformableregistration
   \li \subpage org_mitk_views_pointbasedregistration
   \li \subpage org_mitk_views_rigidregistration
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/ToolExtensionsGeneralOverview.dox b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/ToolExtensionsGeneralOverview.dox
index a30a965483..910d24fc46 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/ToolExtensionsGeneralOverview.dox
+++ b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/ToolExtensionsGeneralOverview.dox
@@ -1,181 +1,181 @@
 /**
 
-\page toolextensions How to extend the Segmentation bundle with external tools
+\page toolextensions How to extend the Segmentation view with external tools
 
 <ul>
 <li> \ref ToolExtensionsGeneralOverview2 </li>
 <li> \ref ToolExtensionsGeneralOverview3 </li>
   <ul>
   <li> \ref ToolExtensionsGeneralOverview31 </li>
   <li> \ref ToolExtensionsGeneralOverview32 </li>
   <li> \ref ToolExtensionsGeneralOverview33 </li>
   </ul>
 <li> \ref ToolExtensionsGeneralOverview4 </li>
 <li> \ref ToolExtensionsGeneralOverview5 </li>
 <li> \ref ToolExtensionsGeneralOverview6 </li>
 </ul>
 
 \section ToolExtensionsGeneralOverview2 Introduction
 
-The application for manual segmentation in MITK (Segmentation bundle) comes
+The application for manual segmentation in MITK (Segmentation view) comes
 with a tool class framework that is extensible with new tools (description at
 \ref QmitkSegmentationTechnicalPage). The usual way
 to create new tools (since it is mostly used inside DKFZ) is to just add new
 files to the MITK source code tree. However, this requires to be familiar with
 the MITK build system and turnaround time during development might be long 
 (recompiling parts of MITK again and again).
 
 For external users who just want to use
 MITK as a library and application, there is a way to create new segmentation 
 tools in an MITK external project, which will compile the new tools into a 
 shared object (DLL). Such shared objects can be loaded via the ITK object factory
 and its autoload feature on application startup. This document describes
 how to build such external extensions.
 
 <b>Example files can be found</b> in the MITK source code in the directory
 <tt>${MITK_SOURCE_DIR}/QApplications/ToolExtensionsExample/</tt>.
 
 \section ToolExtensionsGeneralOverview3 What might be part of an extension
 
 The extension concept assumes that you want to create one or several new
 interactive segmentation tools for Segmentation or another MITK
 functionality that uses the tools infrastructure. In the result you
 will create a shared object (DLL), which contains several tools and their GUI
 counterparts, plus optional code that your extension requires. The following
 sections shortly describe each of these parts.
 
 \subsection ToolExtensionsGeneralOverview31 Tool classes
 
 A tool is basically any subclass of mitk::Tool. Tools are created at runtime
 through the ITK object factory (so they inherit from itk::Object). Tools
 should handle the interaction part of a segmentation method, i.e. create
 seed points, draw contours, etc., in order to parameterize segmentation algorithms.
 Simple algorithms can even be part of a tool. A tools is identified by icon (XPM format),
 name (short string) and optionally a group name (e.g. the group name for Segmentation
 is "default").
 
 <b>There is a naming convention</b>: you should put a tool called \c mitk::ExternalTool into
 files called \c mitkExternalTool.h and \c mitkExternalTool.cpp. This is \e required if
 you use the convenience macros described below, because there need to be ITK factories,
 which names are directly derived from the file names of the tools. For the example of mitk::ExternalTool
 there would be a factory called \c mitk::ExternalToolFactory in a file named \c mitkExternalToolFactory.cpp.
 
 \subsection ToolExtensionsGeneralOverview32 GUI classes for tools
 
 Tools are non-graphical classes that only implement interactions in renderwindows. However,
 some tools will need a means to allow the user to set some parameters -- a graphical user interface, GUI.
 In the Qt3 case, tool GUIs inherit from QmitkToolGUI, which is a mixture of QWidget and itk::Object.
 Tool GUIs are also created through the ITK object factory.
 
 Tools inform their GUIs about state changes by messages. Tool GUIs communicate with their associated tools
 via direct method calls (they know their tools). See mitk::BinaryThresholdTool for examples.
 
 <b>Again a naming convention</b>: if the convenience macros for tool extension shared objects are used,
 you have to put a tool GUI called \c QmitkExternalToolGUI into a files named \c QmitkExternalToolGUI.cpp
 and \c QmitkExternalToolGUI.h. The convenience macro will create a factory called \c QmitkExternalToolGUIFactory
 into a file named \c QmitkExternalToolGUIFactory.cpp.
 
 \subsection ToolExtensionsGeneralOverview33 Additional files
 
 If you are writing tools MITK externally, these tools might depend on additional files, e.g.
 segmentation algorithms. These can also be compiled into a tool extension shared object.
 
 \section ToolExtensionsGeneralOverview4 Writing a CMake file for a tool extension
 
 Summing up the last section, an example tool extension could comprise the following files:
 \verbatim
 mitkExternalTool.h      \
 mitkExternalTool.xpm     >--- implementing mitk::ExternalTool (header, icon, implementation)
 mitkExternalTool.cpp    /
 
 QmitkExternalToolGUI.h    ,-- implementing a GUI for mitk::ExternalTool
 QmitkExternalToolGUI.cpp /
 
 externalalgorithm.h         \
 externalalgorithm.cpp        \
 externalalgorithmsolver.h     >-- a couple of files (not related to MITK tools)
 externalalgorithmsolver.cpp  /
 \endverbatim
 
 This should all be compiled into one shared object. Just like ITK, VTK and MITK we
 will use CMake for this purpose (I assume you either know or are willing to learn about
 <a href="htpp://www.cmake.org">www.cmake.org</a>)
 A CMake file for the above example would look like this:
 
 \code
 project( ExternalTool )
 
 find_package(ITK)
 find_package(MITK)
 find_package(Qt3)
 
 add_definitions(${QT_DEFINITIONS})
 
 set( TOOL_QT3GUI_FILES
      QmitkExternalToolGUI.cpp
    )
 
 set( TOOL_FILES
      mitkExternalTool.cpp
    )
 
 set( TOOL_ADDITIONAL_CPPS
      externalalgorithm.cpp
      externalalgorithmsolver.cpp
    )
 
 set( TOOL_ADDITIONAL_MOC_H
 )
 
 MITK_GENERATE_TOOLS_LIBRARY(mitkExternalTools)
 \endcode
 
 Basically, you only have to change the definitions of \c TOOL_FILES and, optionally, 
 \c TOOL_QT3GUI_FILES, \c TOOL_ADDITIONAL_CPPS and \c TOOL_ADDITIONAL_MOC_H. 
 For all .cpp files in \c TOOL_FILES and \c TOOL_QT3GUI_FILES there will be factories
 created assuming the naming conventions described in the sections above.
 Files listed in \c TOOL_ADDITIONAL_CPPS will just be compiled. Files listed in
 \c TOOL_ADDITIONAL_MOC_H will be run through Qts meta object compiler \c moc -- 
 this is neccessary for all objects that have the Q_OBJECT macro in their declaration.
 \c moc will create new files that will also be compiled into the library.
 
 \section ToolExtensionsGeneralOverview5 Compiling the extension
 
 For compiling a tool extension, you will need a compiled version of MITK. We will
 assume MITK was compiled into /home/user/mitk/debug. You need to build MITK with
 <b>BUILD_SHARED_CORE</b> turned on!
 
 You build the tool extension just like any other CMake based project:
 \li know where your source code is (e.g. /home/user/mitk/tool-extension-src)
 \li change into the directory, where you want to compile the shared object (e.g. /home/user/mitk/tool-extension-debug)
 \li invoke cmake: <tt>ccmake /home/user/mitk/tool-extension-src</tt>
 \li configure (press c or the "configure" button)
 \li set the ITK_DIR variable to the directory, where you compiled ITK
 \li set the MITK_DIR variable to the directory, where you compiled MITK: <tt>/home/user/mitk/debug</tt>
 \li configure (press "c" or the "configure" button)
 \li generate (press "g" or the "generate" button)
 
 This should do it and leave you with a or project file or Makefile that you can compile (using make or VisualStudio).
 
 \section ToolExtensionsGeneralOverview6 Configuring ITK autoload
 
 If the compile succeeds, you will get a library mitkExternalTools.dll or libmitkExternalTools.so.
 This library exports a symbol \c itkLoad which is expected by the ITK object factory.
 
 On application startup the ITK object factory will search a list of directories from 
 the environment variable \c ITK_AUTOLOAD_PATH. Set this environment variable to your binary directory (<tt>/home/user/mitk/tool-extension-debug</tt>).
 
 The ITK object factory will load all shared objects that it finds in the specified directories
 and will test if they contain a symbol (function pointer) \c itkLoad, which is expected
 to return a pointer to a itk::ObjectFactoryBase instance. If such a symbol is found, the
 returned factory will be registered with the ITK object factory.
 
 If you successfully followed all the steps above, MITK will find your mitk::ExternalTool on
 application startup, when the ITK object factory is asked to create all known instances of
 mitk::Tool. Furthermore, if your mitk::ExternalTool claims to be part of the "default" group,
 there will be a new icon in Segmentation, which activates your tool.
 
 <b>Have fun!</b> (And Windows users: welcome to the world of DLLs)
 
 **/
 
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox
index 463e51d867..1947a0c348 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox
+++ b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/org_mitk_gui_qt_segmentation.dox
@@ -1,292 +1,292 @@
 /**
-\page org_mitk_views_segmentation The Segmentation Module
+\page org_mitk_views_segmentation The Segmentation Plugin
 
-\image html segmentation.png "Icon of the Module"
+\image html segmentation.png "Icon of the Plugin"
 
 <i>Some of the features described below  are not available in the open-source part of the MITK-3M3-Application.</i>
 
 Available sections:
 
  - \ref org_mitk_gui_qt_segmentationUserManualOverview
  - \ref org_mitk_gui_qt_segmentationUserManualTechnical
  - \ref org_mitk_gui_qt_segmentationUserManualImageSelection
  - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling
    - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling1
    - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling2
    - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling3
    - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling4
  - \ref org_mitk_gui_qt_segmentationUserManualManualKringeling5
  - \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation
    - \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation1
    - \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation2
    - \ref org_mitk_gui_qt_segmentationUserManualOrganSegmentation99
  - \ref org_mitk_gui_qt_segmentationUserManualLesionSegmentation
  - \ref org_mitk_gui_qt_segmentationUserManualPostprocessing
  - \ref org_mitk_gui_qt_segmentationUserManualSurfaceMasking
  - \ref org_mitk_gui_qt_segmentationUserManualTechnicalDetail
 
 \section org_mitk_gui_qt_segmentationUserManualOverview Overview
 
 The <b>Segmentation perspective</b> allows you to create segmentations of anatomical and pathological structures in medical images of the human body.
 The perspective groups a number of tools which can be used for:
 <ul>
   <li> (semi-)automatic segmentation of organs on CT or MR image volumes
   <li> semi-automatic segmentation of lesions such as enlarged lymph nodes or tumors
   <li> manual segmentation of any structures you might want to delineate
 </ul>
 
 \image html org_mitk_gui_qt_segmentationIMGapplication.png Segmentation perspective consisting of the Data Manager view and the Segmentation view
 
 If you wonder what segmentations are good for, we shortly revisit the concept of a segmentation here.
 A CT or MR image is made up of volume of physical measurements (volume elements are called voxels).
 In CT images, for example, the gray value of each voxel corresponds to the mass absorbtion coefficient for X-rays in this voxel, which is similar in many %parts of the human body.
 The gray value does not contain any further information, so the computer does not know whether a given voxel is part of the body or the background, nor can it tell a brain from a liver.
 However, the distinction between a foreground and a background structure is required when:
 <ul>
 <li>you want to know the volume of a given organ (the computer needs to know which %parts of the image belong to this organ)
 <li>you want to create 3D polygon visualizations (the computer needs to know the surfaces of structures that should be drawn)
 <li>as a necessary pre-processing step for therapy planning, therapy support, and therapy monitoring
 </ul>
 Creating this distinction between foreground and background is called <i>segmentation</i>.
 The Segmentation perspective of the MITK Workbench uses a voxel based approach to segmentation, i.e. each voxel of an image must be completely assigned to either foreground or background.
 This is in contrast to some other applications which might use an approach based on contours, where the border of a structure might cut a voxel into two %parts.
 
 The remainder of this document will summarize the features of the Segmentation perspective and how they are used.
 
 \section org_mitk_gui_qt_segmentationUserManualTechnical Technical Issues
 
-The Segmentation perspective makes a number of assumptions. To know what this module can be used for, it will help you to know that:
+The Segmentation perspective makes a number of assumptions. To know what this view can be used for, it will help you to know that:
 <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 not supported
   <li> Segmentations are handled as binary images of the same extent as the original image
 </ul>
 
 \section org_mitk_gui_qt_segmentationUserManualImageSelection Image Selection
 
 The Segmentation perspective makes use of the Data Manager view to give you an overview of all images and segmentations. 
 
 \image html org_mitk_gui_qt_segmentationIMGselection.png Data Manager is used for selecting the current segmentation. The reference image is selected in the drop down box of the control area.
 
 To select the reference image (e.g. the original CT/MR image) use the drop down box in the control area of the Segmentation view. The segmentation image selected in the Data Manager is displayed below the drop down box. If no segmentation image exists or none is selected create a new segmentation image by using the "New segmentation" button.
 Some items of the graphical user interface might be disabled when no image is selected.
 In any case, the application will give you hints if a selection is needed.
 
 \section org_mitk_gui_qt_segmentationUserManualManualKringeling Manual Contouring
 
 With manual contouring you define which voxels are part of the segmentation and which are not.
 This allows you to create segmentations of any structeres that you may find in an image, even if they are not part of the human body.
 You might 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 moderated by the interpolation feature, which will make suggestions for a segmentation.
 
 \subsection org_mitk_gui_qt_segmentationUserManualManualKringeling1 Creating New Segmentations
 
 Unless you want to edit existing segmentations, you have to create a new, empty segmentation before you can edit it.
 To do so, click the "New manual segmentation" button.
 Input fields will appear where you can choose a name for the new segmentation and a color for its display.
 Click the checkmark button to confirm or the X button to cancel the new segmentation.
 Notice that the input field suggests names once you %start typing and that it also suggests colors for known organ names.
 If you use names that are not yet known to the application, it will automatically remember these names and consider them the next time you create a new segmentation.
 
 Once you created a new segmentation, you can notice a new item with the "binary mask" icon in the Data Manager tree view.
 This item is automatically selected for you, allowing you to %start editing the new segmentation right away.
 
 \subsection org_mitk_gui_qt_segmentationUserManualManualKringeling2 Selecting Segmentations for Editing
 
 As you might want to have segmentations of multiple structures in a single patient image, the application needs to know which of them to use for editing.
 You select a segmenation by clicking it in the tree view of Data Manager. Note that segmentations are usually displayed as sub-items of "their" patient image.
 In the rare case, where you need to edit a segmentation that is not displayed as a a sub-item, you can click both the original image AND the segmentation while holding down CTRL or for Mac OS X the CMD on the keyboard.
 
 When a selection is made, the Segmentation View will hide all but the selected segmentation and the corresponding original image.
 When there are multiple segmentations, the unselected ones will remain in the Data Manager, you can make them visible at any time by selecting them.
 
 \subsection org_mitk_gui_qt_segmentationUserManualManualKringeling3 Selecting Editing Tools
 
 If you are familiar with the MITK Workbench, you know that clicking and moving the mouse in any of the 2D render windows will move around the crosshair that defines what part of the image is displayed.
 This behavior is disabled while any of the manual segmentation tools are active -- otherwise you might have a hard time concentrating on the contour you are drawing.
 
 To %start using one of the editing tools, click its button the 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.
 
 If you have to delineate a lot of images, you should try using shortcuts to switch tools. Just hit the first letter of each tool to activate it (A for Add, S for Subtract, etc.).
 
 \subsection org_mitk_gui_qt_segmentationUserManualManualKringeling4 Using Editing Tools
 
 All of the editing tools work by the same principle: you use the mouse (left button) to click anywhere in a 2D window (any of the orientations axial, sagittal, or frontal), move the mouse while holding the mouse button and release to finish the editing action.
 
 Multi-step undo and redo is fully supported by all editing tools. Use the application-wide undo button in the toolbar to revert erroneous %actions.
 
 \image html org_mitk_gui_qt_segmentationIMGiconAddSubtract.png Add and Subtract Tools
 
 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 from (Subtract tool) the current segmentation.
 Hold down the CTRL / CMD key to invert the operation (this will switch tools temporarily to allow for quick corrections).
 
 \image html org_mitk_gui_qt_segmentationIMGiconPaintWipe.png Paint and Wipe Tools
 
 Use the slider below the toolbox to change the radius of these round paintbrush tools. Move the mouse in any 2D window and press the left button to draw or erase pixels.
 As the Add/Subtract tools, holding CTRL / CMD while drawing will invert the current tool's behavior.
 
 \image html org_mitk_gui_qt_segmentationIMGiconRegionGrowing.png Region Growing Tool
 
 Click at one point in a 2D slice widget to add an image region to the segmentation with the region growing tool. Moving up the cursor while holding the left mouse button widens the range for the included grey values; moving it down narrows it.
 When working on an image with a high range of grey values, the selection range can be influenced more strongly by moving the cursor at higher velocity.
 
 Region Growing selects all pixels around the mouse cursor that have a similar gray value as the pixel below the mouse cursor.
 This enables you to quickly create segmentations of structures that have a good contrast to surrounding tissue, e.g. the lungs.
 The tool will select more or less pixels (corresponding to a changing gray value interval width) when you move the mouse up or down while holding down the left mouse button.
 
 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).
 
 \image html org_mitk_gui_qt_segmentationIMGleakage.png Leakage correction feature of the Region Growing tool
 <br>
 \image html org_mitk_gui_qt_segmentationIMGiconCorrection.png Correction Tool
 
 You do not have to draw a closed contour to use the Correction tool and do not need to switch between the Add and Substract tool to perform
 small corrective changes. The following figure shows the usage of this tool:
 <ul>
 <li> if the user draws a line which %starts and ends outside the segmenation AND it intersects no other segmentation the endpoints of the line are connected and the resulting contour is filled
 <li> if the user draws a line which %starts and ends outside the segmenation a part of it is cut off (left image)
 <li> if the line is drawn fully inside the segmentation the marked region is added to the segmentation (right image)
 </ul>
 
 \image html org_mitk_gui_qt_segmentationIMGcorrectionActions.png %Actions of the Correction tool illustrated.
 <br>
 \image html org_mitk_gui_qt_segmentationIMGiconFill.png Fill Tool
 
 Left-click inside a segmentation with holes to completely fill all holes.
 
 \image html org_mitk_gui_qt_segmentationIMGiconErase.png Erase Tool
 
 This tool removes a connected part of pixels that form a segmentation. You may use it to remove so called islands (see picture) or to clear a whole slice at once (hold CTRL while clicking).
 
 \subsection org_mitk_gui_qt_segmentationUserManualManualKringeling5 Interpolation
 
 Creating segmentations for modern CT volumes is very time-consuming, because structures of interest can easily cover a range of 50 or more slices.
 The Manual Segmentation View offers two helpful features for these cases: 
 
 <ul>
 <li> <b>3D Interpolation</b>
 <li> <b>2D Interpolation</b>
 </ul>
 <br>
 <b>The 3D interpolation</b> is activated by default when using the manual segmentation tools. 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. 
 
 \image html org_mitk_gui_qt_segmentation3DInterpolationWrongRight.png 3D Interpolation HowTo
 
 You can accept the interpolation result by clicking the "Accept" - button below the tool buttons. 
 In this case the 3D interpolation will be deactivated automatically so that the result can be postprocessed without any interpolation running in background. During recalculation the interpolated surface is blinking yellow/white. When the interpolation 
 has finished the surface is shown yellow with a small opacity. Additional to the surface, black contours are shown in the 3D render window. They mark the positions of all the drawn contours which were used for the interpolation. 
 You can navigate between the drawn contours by clicking on the „Position“ - Nodes in the datamanager which are located below the selected segmentation. If you don't want to see these nodes just unckeck the „Show Position Nodes“ Checkbox and these nodes will be hidden.
 If you want to delete a drawn contour we recommend to use the Erase-Tool since Redo/Undo is not yet working for 3D interpolation.
 
 <br>
 <b>The 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>
 
 Interpolated suggestions are displayed in a different way than manual segmentations are, until you "accept" them as part of the segmentation.
 To accept single slices, click the "Accept" button below the toolbox.
 If you have segmented a whole organ in every-x-slice, you may also review the interpolations and then accept all of them at once by clicking "... all slices".
 
 \section org_mitk_gui_qt_segmentationUserManualOrganSegmentation Organ Segmentation
 
 \note This feature is only available in our 3M3 Demo Application (http://www.mint-medical.de/productssolutions/mitk3m3/mitk3m3/#downloads) but not in the open source part of MITK
 
 The manual contouring described above is a fallback option that will work for any kind of images and structures of interest.
 However, manual contouring is very time-consuming and tedious.
 This is why a major part of image analysis research is working towards automatic segmentation methods.
 The Segmentation View comprises a number of easy-to-use tools for segmentation of CT images (Liver) and MR image (left ventricle and wall, left and right lung).
 
 \subsection org_mitk_gui_qt_segmentationUserManualOrganSegmentation1 Liver on CT Images
 
 On CT image volumes, preferrably with a contrast agent in the portal venous phase, the Liver tool will fully automatically analyze and segment the image.
 All you have to do is to load and select the image, then click the "Liver" button.
 During the process, which takes a minute or two, you will get visual progress feedback by means of a contour that moves closer and closer to the real liver boundaries.
 
 \subsection org_mitk_gui_qt_segmentationUserManualOrganSegmentation2 Heart, Lung, and Hippocampus on MRI
 
 While liver segmentation is performed fully automatic, the following tools for segmentation of the heart, the lungs, and the hippocampus need a minimum amount of guidance.
 Click one of the buttons on the "Organ segmentation" page to add an average %model of the respective organ to the image.
 This %model can be dragged to the right position by using the left mouse button while holding down the CTRL key.
 You can also use CTRL + middle mouse button to rotate or CTRL + right mouse button to scale the %model.
 
 Before starting the automatic segmentation process by clicking the "Start segmentation" button, try placing the %model closely to the organ in the MR image
 (in most cases, you do not need to rotate or scale the %model).
 During the segmentation process, a green contour that moves closer and closer to the real liver boundaries will provide you with visual feedback of the segmentation progress.
 
 The algorithms used for segmentation of the heart and lung are method which need training by a number of example images.
 They will not work well with other kind of images, so here is a list of the image types that were used for training:
 <ul>
 <li> Hippocampus segmentation: T1-weighted MR images, 1.5 Tesla scanner (Magnetom Vision, Siemens Medical Solutions), 1.0 mm isotropic resolution
 <li> Heart: Left ventricle inner segmentation (LV Model): MRI; velocity encoded cine (VEC-cine) MRI sequence; trained on systole and diastole
 <li> Heart: Left ventricular wall segmentation (LV Inner Wall, LV Outer Wall): 4D MRI; short axis 12 slice spin lock sequence(SA_12_sl); trained on whole heart cycle
 <li> Lung segmentation: 3D and 4D MRI; works best on FLASH3D and TWIST4D sequences
 </ul>
 
 \subsection org_mitk_gui_qt_segmentationUserManualOrganSegmentation99 Other Organs
 
 As mentioned in the Heart/Lung section, most of the underlying methods are based on "training".
 The basic algorithm is versatile and can be applied on all kinds of segmentation problems where the structure of interest is topologically like a sphere (and not like a torus etc.).
 If you are interested in other organs than those offered by the current version of the Segmentation view,
 please contact our research team.
 
 \section org_mitk_gui_qt_segmentationUserManualLesionSegmentation Lesion Segmentation
 
 \note This feature is only available in our 3M3 Demo Application (http://www.mint-medical.de/productssolutions/mitk3m3/mitk3m3/#downloads) but not in the open source part of MITK
 
 Lesion segmentation is a little different from organ segmentation. Since lesions are not part of the healthy body, they sometimes have a diffused border,
 and are often found in varying places all over the body.
 The tools in this section offer efficient ways to create 3D segmentations of such lesions.
 
 The Segmentation View currently offers supoprt for enlarged lymph nodes.
 
 To segment an enlarged lymph node, find a more or less central slice of it, activate the "Lymph Node" tool and draw a rough contour on the inside of the lymph node.
 When releaseing the mouse button, a segmentation algorithm is started in a background task. The result will become visible after a couple of seconds, but you do not have to wait for it.
 If you need to segment several lymph nodes, you can continue to inspect the image right after closing the drawn contour.
 
 If the lymph node segmentation is not to your content, you can select the "Lymph Node Correction" tool and drag %parts of the lymph node surface towards the right position (works in 3D, not slice-by-slice).
 This kind of correction helps in many cases.
 If nothing else helps, you can still use the pure manual tools as a fallback.
 
 \section org_mitk_gui_qt_segmentationUserManualPostprocessing Things you can do with segmentations
 
 As mentioned in the introduction, segmentations are never an end in themselves.
 Consequently, the Segmentation view adds a couple of "post-processing" %actions to the Data Manager.
 These %actions are accessible through the context-menu of segmentations in Data Manager's list view
 
 \image html org_mitk_gui_qt_segmentationIMGDataManagerContextMenu.png Context menu items for segmentations.
 
 <ul>
 <li> <b>Create polygon %model</b> applies the marching cubes algorithms to the segmentation. This polygon %model can be used for visualization in 3D or other things such as stereolithography (3D printing).
 <li> <b>Create smoothed polygon %model</b> uses smoothing in addition to the marching cubes algorithms, which creates models that do not follow the exact outlines of the segmentation, but look smoother.
 <li> <b>Statistics</b> goes through all the voxels in the patient image that are part of the segmentation and calculates some statistical measures (minumum, maximum, median, histogram, etc.). Note that the statistics are ALWAYS calculated for the parent element of the segmentation as shown in Data Manager.
 <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_gui_qt_segmentationUserManualSurfaceMasking Surface Masking
 
 You can use the surface masking tool to create binary images from a surface which
 is used used as a mask on an image. This task is demonstrated below:
 
 \image html segmentationFromSurfaceBefore.png Load an image and a surface. 
 
 Select the image and the surface in the corresponding drop-down boxes (both are selected automatically if there is just one image and one surface)
 
 \image html segmentationFromSurfaceAfter.png Create segmentation from surface
 
 After clicking "Create segmentation from surface" the newly created binary image is inserted in the DataManager and can be used for further processing
 
 \section org_mitk_gui_qt_segmentationUserManualTechnicalDetail 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/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index c4142a51a5..a6b552aa70 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,1211 +1,1225 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
-Copyright (c) German Cancer Research Center, 
+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 
+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 "mitkDataNodeObject.h"
 #include "mitkProperties.h"
 #include "mitkSegTool2D.h"
 #include "mitkGlobalInteraction.h"
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkNewSegmentationDialog.h"
 
 #include <QMessageBox>
 
 #include <berryIWorkbenchPage.h>
 
 #include "QmitkSegmentationView.h"
 #include "QmitkSegmentationPostProcessing.h"
 #include "QmitkSegmentationOrganNamesHandling.cpp"
 
 #include <mitkSurfaceToImageFilter.h>
 #include <vtkPolyData.h>
 
 //For Segmentation in rotated slices
 //TODO clean up includes
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkPlanarCircle.h"
 
 #include "mitkGetModuleContext.h"
 #include "mitkModule.h"
 #include "mitkModuleRegistry.h"
 
 #include "mitkSegmentationObjectFactory.h"
 
 const std::string QmitkSegmentationView::VIEW_ID =
 "org.mitk.views.segmentation";
 
 // public methods
 
 QmitkSegmentationView::QmitkSegmentationView()
 :m_Parent(NULL)
 ,m_Controls(NULL)
 ,m_MultiWidget(NULL)
 ,m_RenderingManagerObserverTag(0)
+,m_DataSelectionChanged(false)
 {
   RegisterSegmentationObjectFactory();
 }
 
 QmitkSegmentationView::~QmitkSegmentationView()
 {
   // delete m_PostProcessing;
   delete m_Controls;
 }
 
 void QmitkSegmentationView::NewNodesGenerated()
 {
 //  ForceDisplayPreferencesUponAllImages();
 }
 
 void QmitkSegmentationView::NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType* nodes)
 {
   if (!nodes) return;
 
   mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
   if (!toolManager) return;
   for (mitk::ToolManager::DataVectorType::iterator iter = nodes->begin(); iter != nodes->end(); ++iter)
   {
     this->FireNodeSelected( *iter );
     // only last iteration meaningful, multiple generated objects are not taken into account here
   }
 }
 
+void QmitkSegmentationView::Visible()
+{
+  if (m_DataSelectionChanged)
+  {
+    this->OnSelectionChanged(this->GetDataManagerSelection());
+  }
+}
+
 void QmitkSegmentationView::Activated()
 {
   // should be moved to ::BecomesVisible() or similar
   if( m_Controls )
   {
     m_Controls->m_ManualToolSelectionBox->setEnabled( true );
     m_Controls->m_OrganToolSelectionBox->setEnabled( true );
     m_Controls->m_LesionToolSelectionBox->setEnabled( true );
 
     m_Controls->m_SlicesInterpolator->Enable3DInterpolation( m_Controls->widgetStack->currentWidget() == m_Controls->pageManual );
 
     //TODO Remove Observer
     itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command1 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
     command1->SetCallbackFunction( this, &QmitkSegmentationView::RenderingManagerReinitialized );
     m_RenderingManagerObserverTag = mitk::RenderingManager::GetInstance()->AddObserver( mitk::RenderingManagerViewsInitializedEvent(), command1 );
 
     //Adding observers for node visibility to existing segmentations
     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 isSegmentation = mitk::NodePredicateAnd::New( isImage, isBinary );
 
     mitk::DataStorage::SetOfObjects::ConstPointer segmentations = this->GetDefaultDataStorage()->GetSubset( isSegmentation );
 
     for ( mitk::DataStorage::SetOfObjects::const_iterator iter = segmentations->begin();
       iter != segmentations->end();
       ++iter)
     {
         mitk::DataNode* node = *iter;
         itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
         command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
         m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( node, node->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
     }
 
     if(segmentations->Size() > 0)
     {
       FireNodeSelected(segmentations->ElementAt(0));
       segmentations->ElementAt(0)->GetProperty("visible")->Modified();
     }
   }
 }
 
 void QmitkSegmentationView::Deactivated()
 {
   if( m_Controls )
   {
     mitk::RenderingManager::GetInstance()->RemoveObserver( m_RenderingManagerObserverTag );
     m_Controls->m_ManualToolSelectionBox->setEnabled( false );
     //deactivate all tools
     m_Controls->m_ManualToolSelectionBox->GetToolManager()->ActivateTool(-1);
     m_Controls->m_OrganToolSelectionBox->setEnabled( false );
     m_Controls->m_LesionToolSelectionBox->setEnabled( false );
     m_Controls->m_SlicesInterpolator->EnableInterpolation( false );
 
     //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();
 
     if (m_MultiWidget)
     {
       mitk::SlicesCoordinator *coordinator = m_MultiWidget->GetSlicesRotator();
-      
+
       if (coordinator)
         coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
 
       coordinator = m_MultiWidget->GetSlicesSwiveller();
-      
+
       if (coordinator)
         coordinator->RemoveObserver(m_SlicesRotationObserverTag2);
 
     }
 
     // gets the context of the "Mitk" (Core) module (always has id 1)
     // TODO Workaround until CTL plugincontext is available
     mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
     // Workaround end
     mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
     //mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
     service->RemoveAllPlanePositions();
   }
 }
 
 void QmitkSegmentationView::StdMultiWidgetAvailable( QmitkStdMultiWidget& stdMultiWidget )
 {
   SetMultiWidget(&stdMultiWidget);
 }
 
 void QmitkSegmentationView::StdMultiWidgetNotAvailable()
 {
   SetMultiWidget(NULL);
 }
 
 void QmitkSegmentationView::StdMultiWidgetClosed( QmitkStdMultiWidget& /*stdMultiWidget*/ )
 {
   SetMultiWidget(NULL);
 }
 
 void QmitkSegmentationView::SetMultiWidget(QmitkStdMultiWidget* multiWidget)
 {
   if (m_MultiWidget)
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if (coordinator)
     {
       coordinator->RemoveObserver( m_SlicesRotationObserverTag1 );
     }
     coordinator = m_MultiWidget->GetSlicesSwiveller();
     if (coordinator)
     {
       coordinator->RemoveObserver( m_SlicesRotationObserverTag2 );
     }
   }
 
   // save the current multiwidget as the working widget
   m_MultiWidget = multiWidget;
 
   //TODO Remove Observers
   if (m_MultiWidget)
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if (coordinator)
     {
       itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
       command2->SetCallbackFunction( this, &QmitkSegmentationView::SliceRotation );
       m_SlicesRotationObserverTag1 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
     }
 
     coordinator = m_MultiWidget->GetSlicesSwiveller();
     if (coordinator)
     {
       itk::ReceptorMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSegmentationView>::New();
       command2->SetCallbackFunction( this, &QmitkSegmentationView::SliceRotation );
       m_SlicesRotationObserverTag2 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
     }
   }
   //TODO End Remove Observers
 
   if (m_Parent)
   {
     m_Parent->setEnabled(m_MultiWidget);
   }
 
   // tell the interpolation about toolmanager and multiwidget (and data storage)
   if (m_Controls && m_MultiWidget)
   {
     mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
     m_Controls->m_SlicesInterpolator->SetDataStorage( *(this->GetDefaultDataStorage()));
     m_Controls->m_SlicesInterpolator->Initialize( toolManager, m_MultiWidget );
   }
 }
 
 void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences*)
 {
   ForceDisplayPreferencesUponAllImages();
 }
 
 //TODO remove function
 void QmitkSegmentationView::RenderingManagerReinitialized(const itk::EventObject&)
 {
   CheckImageAlignment();
 }
 
 //TODO remove function
 void QmitkSegmentationView::SliceRotation(const itk::EventObject&)
 {
   CheckImageAlignment();
 }
 
 
 // protected slots
 
 void QmitkSegmentationView::CreateNewSegmentation()
 {
   mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
   if (node.IsNotNull())
   {
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
     if (image.IsNotNull())
     {
       if (image->GetDimension()>1)
       {
         // ask about the name and organ type of the new segmentation
         QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog( m_Parent ); // needs a QWidget as parent, "this" is not QWidget
 
         QString storedList = QString::fromStdString( this->GetPreferences()->GetByteArray("Organ-Color-List","") );
         QStringList organColors;
         if (storedList.isEmpty())
         {
           organColors = GetDefaultOrganColorString();
         }
         else
         {
           /*
           a couple of examples of how organ names are stored:
 
           a simple item is built up like 'name#AABBCC' where #AABBCC is the hexadecimal notation of a color as known from HTML
 
           items are stored separated by ';'
           this makes it necessary to escape occurrences of ';' in name.
           otherwise the string "hugo;ypsilon#AABBCC;eugen#AABBCC" could not be parsed as two organs
           but we would get "hugo" and "ypsilon#AABBCC" and "eugen#AABBCC"
 
           so the organ name "hugo;ypsilon" is stored as "hugo\;ypsilon"
           and must be unescaped after loading
 
           the following lines could be one split with Perl's negative lookbehind
           */
 
           // recover string list from BlueBerry view's preferences
           QString storedString = QString::fromStdString( this->GetPreferences()->GetByteArray("Organ-Color-List","") );
           MITK_DEBUG << "storedString: " << storedString.toStdString();
           // match a string consisting of any number of repetitions of either "anything but ;" or "\;". This matches everything until the next unescaped ';'
           QRegExp onePart("(?:[^;]|\\\\;)*");
           MITK_DEBUG << "matching " << onePart.pattern().toStdString();
           int count = 0;
           int pos = 0;
           while( (pos = onePart.indexIn( storedString, pos )) != -1 )
           {
             ++count;
             int length = onePart.matchedLength();
             if (length == 0) break;
             QString matchedString = storedString.mid(pos, length);
             MITK_DEBUG << "   Captured length " << length << ": " << matchedString.toStdString();
             pos += length + 1; // skip separating ';'
 
             // unescape possible occurrences of '\;' in the string
             matchedString.replace("\\;", ";");
 
             // add matched string part to output list
             organColors << matchedString;
           }
           MITK_DEBUG << "Captured " << count << " organ name/colors";
         }
 
         dialog->SetSuggestionList( organColors );
 
         int dialogReturnValue = dialog->exec();
 
         if ( dialogReturnValue == QDialog::Rejected ) return; // user clicked cancel or pressed Esc or something similar
 
         // ask the user about an organ type and name, add this information to the image's (!) propertylist
         // create a new image of the same dimensions and smallest possible pixel type
         mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
         mitk::Tool* firstTool = toolManager->GetToolById(0);
         if (firstTool)
         {
           try
           {
             mitk::DataNode::Pointer emptySegmentation =
               firstTool->CreateEmptySegmentationNode( image, dialog->GetSegmentationName().toStdString(), dialog->GetColor() );
 
             //Here we change the reslice interpolation mode for a segmentation, so that contours in rotated slice can be shown correctly
             emptySegmentation->SetProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_NEAREST) );
             // initialize showVolume to false to prevent recalculating the volume while working on the segmentation
             emptySegmentation->SetProperty( "showVolume", mitk::BoolProperty::New( false ) );
 
             if (!emptySegmentation) return; // could be aborted by user
 
             UpdateOrganList( organColors, dialog->GetSegmentationName(), dialog->GetColor() );
 
             /*
             escape ';' here (replace by '\;'), see longer comment above
             */
             std::string stringForStorage = organColors.replaceInStrings(";","\\;").join(";").toStdString();
             MITK_DEBUG << "Will store: " << stringForStorage;
             this->GetPreferences()->PutByteArray("Organ-Color-List", stringForStorage );
             this->GetPreferences()->Flush();
 
             if(m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0))
             {
               m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0)->SetSelected(false);
             }
             emptySegmentation->SetSelected(true);
             this->GetDefaultDataStorage()->Add( emptySegmentation, node ); // add as a child, because the segmentation "derives" from the original
 
             this->FireNodeSelected( emptySegmentation );
             this->OnSelectionChanged( emptySegmentation );
             this->SetToolManagerSelection(node, emptySegmentation);
           }
           catch (std::bad_alloc)
           {
             QMessageBox::warning(NULL,"Create new segmentation","Could not allocate memory for new segmentation");
           }
         }
       }
       else
       {
         QMessageBox::information(NULL,"Segmentation","Segmentation is currently not supported for 2D images");
       }
     }
   }
   else
   {
     MITK_ERROR << "'Create new segmentation' button should never be clickable unless a patient image is selected...";
   }
 }
 
 void QmitkSegmentationView::OnWorkingNodeVisibilityChanged(/*const itk::Object* caller, const itk::EventObject& e*/)
 {
   if (!m_Parent || !m_Parent->isVisible()) return;
 
   // The new selection behaviour is:
-  // 
+  //
   // When clicking on the checkbox of a segmentation the node will e selected and its reference node either
   // The previous selected segmentation (if there is one) will be deselected. Additionally a reinit on the
   // selected segmenation will be performed.
   // If more than one segmentation is selected the tools will be disabled.
 
   if (!m_Controls) return; // might happen on initialization (preferences loaded)
   mitk::DataNode::Pointer referenceDataNew = mitk::DataNode::New();
   mitk::DataNode::Pointer workingData;
 
   bool workingNodeIsVisible (true);
 
   unsigned int numberOfSelectedSegmentations (0);
 
   // iterate all images
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
 
   mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDefaultDataStorage()->GetSubset( isImage );
   for ( mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin();
     iter != allImages->end();
     ++iter)
   {
     mitk::DataNode* node = *iter;
     // apply display preferences
     ApplyDisplayOptions(node);
 
     bool isSegmentation(false);
     node->GetBoolProperty("binary", isSegmentation);
     if (node->IsSelected() && isSegmentation)
     {
       workingNodeIsVisible =  node->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
       if (!workingNodeIsVisible)
         return;
       numberOfSelectedSegmentations++;
 
       workingData = node;
 
       if (this->GetDefaultDataStorage()->GetSources(node)->Size() != 0)
       {
           referenceDataNew = this->GetDefaultDataStorage()->GetSources(node)->ElementAt(0);
       }
 
       bool isBinary(false);
 
       //Find topmost source or first source which is no binary image
       while (referenceDataNew && this->GetDefaultDataStorage()->GetSources(referenceDataNew)->Size() != 0)
       {
         referenceDataNew = this->GetDefaultDataStorage()->GetSources(referenceDataNew)->ElementAt(0);
 
         referenceDataNew->GetBoolProperty("binary",isBinary);
         if (!isBinary)
             break;
       }
 
       if (workingNodeIsVisible && referenceDataNew)
       {
           //Since the binary property of a segmentation can be set to false and afterwards you can create a new segmentation out of it
           //->could lead to a deadloop
           NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( referenceDataNew );
           if ( searchIter != m_WorkingDataObserverTags.end())
           {
               referenceDataNew->GetProperty("visible")->RemoveObserver( (*searchIter).second );
           }
           referenceDataNew->SetVisibility(true);
       }
 
       //set comboBox to reference image
       disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
         this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
       m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(referenceDataNew) );
 
       connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
         this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
       continue;
     }
     if (workingData.IsNull() || (workingNodeIsVisible && node != referenceDataNew))
     {
       node->SetVisibility((false));
     }
   }
   if(numberOfSelectedSegmentations == 1)
     SetToolManagerSelection(referenceDataNew, workingData);
 
   mitk::DataStorage::SetOfObjects::Pointer temp = mitk::DataStorage::SetOfObjects::New();
   temp->InsertElement(0,workingData);
   mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(temp);
 
   // initialize the views to the bounding geometry
   /*mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();*/
 }
 
 void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
 {
   bool isSeg(false);
   bool isHelperObject(false);
   node->GetBoolProperty("helper object", isHelperObject);
   node->GetBoolProperty("binary", isSeg);
   if(isSeg && !isHelperObject)
   {
     mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(node, mitk::NodePredicateProperty::New("isContourMarker"
       , mitk::BoolProperty::New(true)));
 
     // gets the context of the "Mitk" (Core) module (always has id 1)
     // TODO Workaround until CTL plugincontext is available
     mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
     // Workaround end
     mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
     //mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
 
     mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
 
     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());
     }
     mitk::DataNode* tempNode = const_cast<mitk::DataNode*>(node);
     node->GetProperty("visible")->RemoveObserver( m_WorkingDataObserverTags[tempNode] );
     m_WorkingDataObserverTags.erase(tempNode);
   }
 
   if((m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0) == node)||
     (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0) == node))
   {
   //as we don't know which node was actually remove e.g. our reference node, disable 'New Segmentation' button.
   //consider the case that there is no more image in the datastorage
     this->SetToolManagerSelection(NULL, NULL);
   }
 }
 
 void QmitkSegmentationView::CreateSegmentationFromSurface()
-{ 
+{
   mitk::DataNode::Pointer surfaceNode =
     m_Controls->MaskSurfaces->GetSelectedNode();
   mitk::Surface::Pointer surface(0);
   if(surfaceNode.IsNotNull())
     surface = dynamic_cast<mitk::Surface*> ( surfaceNode->GetData() );
   if(surface.IsNull())
   {
     this->HandleException( "No surface selected.", m_Parent, true);
     return;
   }
 
   mitk::DataNode::Pointer imageNode
     = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
   mitk::Image::Pointer image(0);
   if (imageNode.IsNotNull())
     image = dynamic_cast<mitk::Image*>( imageNode->GetData() );
   if(image.IsNull())
   {
     this->HandleException( "No image selected.", m_Parent, true);
     return;
   }
 
   mitk::SurfaceToImageFilter::Pointer s2iFilter
     = mitk::SurfaceToImageFilter::New();
 
   s2iFilter->MakeOutputBinaryOn();
   s2iFilter->SetInput(surface);
   s2iFilter->SetImage(image);
   s2iFilter->Update();
 
   mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
   std::string nameOfResultImage = imageNode->GetName();
   nameOfResultImage.append(surfaceNode->GetName());
   resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
   resultNode->SetProperty("binary", mitk::BoolProperty::New(true) );
   resultNode->SetData( s2iFilter->GetOutput() );
 
   this->GetDataStorage()->Add(resultNode, imageNode);
 
 }
 
 void QmitkSegmentationView::ToolboxStackPageChanged(int id)
 {
   // interpolation only with manual tools visible
   m_Controls->m_SlicesInterpolator->EnableInterpolation( id == 0 );
 
   if( id == 0 )
   {
     mitk::DataNode::Pointer workingData =   m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0);
     if( workingData.IsNotNull() )
     {
       m_Controls->lblSegmentation->setText( workingData->GetName().c_str() );
       m_Controls->lblSegImage->show();
       m_Controls->lblSegmentation->show();
     }
   }
   else
   {
     m_Controls->lblSegImage->hide();
     m_Controls->lblSegmentation->hide();
   }
 
   // this is just a workaround, should be removed when all tools support 3D+t
   if (id==2) // lesions
   {
     mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
     if (node.IsNotNull())
     {
       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
       if (image.IsNotNull())
       {
         if (image->GetDimension()>3)
         {
           m_Controls->widgetStack->setCurrentIndex(0);
           QMessageBox::information(NULL,"Segmentation","Lesion segmentation is currently not supported for 4D images");
         }
       }
     }
   }
 }
 
 // protected
 
 void QmitkSegmentationView::OnComboBoxSelectionChanged( const mitk::DataNode* node )
 {
   mitk::DataNode* selectedNode = const_cast<mitk::DataNode*>(node);
   if( selectedNode != NULL )
   {
     m_Controls->refImageSelector->show();
     m_Controls->lblReferenceImageSelectionWarning->hide();
 
     bool isBinary(false);
     selectedNode->GetBoolProperty("binary", isBinary);
     if ( isBinary )
     {
       FireNodeSelected(selectedNode);
       selectedNode->SetVisibility(true);
     }
     else if (node != m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0))
     {
       if (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0))
         m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0)->SetVisibility(false);
       if (m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0))
       {
         m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0)->SetVisibility(false);
       }
       FireNodeSelected(selectedNode);
       selectedNode->SetVisibility(true);
       SetToolManagerSelection(selectedNode, NULL);
     }
   }
   else
   {
     m_Controls->refImageSelector->hide();
     m_Controls->lblReferenceImageSelectionWarning->show();
   }
 }
 
 
 void QmitkSegmentationView::OnShowMarkerNodes (bool state)
 {
   mitk::SegTool2D::Pointer manualSegmentationTool;
 
   unsigned int numberOfExistingTools = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetTools().size();
 
   for(unsigned int i = 0; i < numberOfExistingTools; i++)
   {
     manualSegmentationTool = dynamic_cast<mitk::SegTool2D*>(m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetToolById(i));
 
     if (manualSegmentationTool)
     {
       if(state == true)
       {
         manualSegmentationTool->SetShowMarkerNodes( true );
       }
       else
       {
         manualSegmentationTool->SetShowMarkerNodes( false );
       }
     }
   }
 }
 
 void QmitkSegmentationView::OnSelectionChanged(mitk::DataNode* node)
 {
   std::vector<mitk::DataNode*> nodes;
   nodes.push_back( node );
   this->OnSelectionChanged( nodes );
 }
 
 void QmitkSegmentationView::OnSurfaceSelectionChanged()
-{   
+{
   // if Image and Surface are selected, enable button
   if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
     (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()))
     m_Controls->CreateSegmentationFromSurface->setEnabled(false);
   else
     m_Controls->CreateSegmentationFromSurface->setEnabled(true);
 }
 
 void QmitkSegmentationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
 {
   // if the selected node is a contourmarker
   if ( !nodes.empty() )
   {
     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 ) );
     }
   }
 
   // if Image and Surface are selected, enable button
   if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
     (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()))
     m_Controls->CreateSegmentationFromSurface->setEnabled(false);
   else
     m_Controls->CreateSegmentationFromSurface->setEnabled(true);
 
-  if (!m_Parent || !m_Parent->isVisible()) return;
+  m_DataSelectionChanged = false;
+  if (!m_Parent || !m_Parent->isVisible())
+  {
+    m_DataSelectionChanged = true;
+    return;
+  }
 
   // reaction to BlueBerry selection events
   //   this method will try to figure out if a relevant segmentation and its corresponding original image were selected
   //   a warning is issued if the selection is invalid
   //   appropriate reactions are triggered otherwise
 
   mitk::DataNode::Pointer referenceData = FindFirstRegularImage( nodes ); //m_Controls->refImageSelector->GetSelectedNode(); //FindFirstRegularImage( nodes );
   mitk::DataNode::Pointer workingData =   FindFirstSegmentation( nodes );
 
   if(referenceData.IsNull() && workingData.IsNull())
     return;
 
   bool invalidSelection( !nodes.empty() &&
     (
     nodes.size() > 2 ||    // maximum 2 selected nodes
     (nodes.size() == 2 && (workingData.IsNull() || referenceData.IsNull()) ) || // with two nodes, one must be the original image, one the segmentation
     ( workingData.GetPointer() == referenceData.GetPointer() ) //one node is selected as reference and working image
     // one item is always ok (might be working or reference or nothing
     )
     );
 
   if (invalidSelection)
   {
     // TODO visible warning when two images are selected
     MITK_ERROR << "WARNING: No image, too many (>2) or two equal images were selected.";
     workingData = NULL;
 
     if( m_Controls->refImageSelector->GetSelectedNode().IsNull() )
       referenceData = NULL;
   }
 
   if ( workingData.IsNotNull() && referenceData.IsNull() )
   {
     // find the DataStorage parent of workingData
     // try to find a "normal image" parent, select this as reference image
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
     mitk::NodePredicateNot::Pointer isNotBinary = mitk::NodePredicateNot::New( isBinary );
     mitk::NodePredicateAnd::Pointer isNormalImage = mitk::NodePredicateAnd::New( isImage, isNotBinary );
 
     mitk::DataStorage::SetOfObjects::ConstPointer possibleParents = this->GetDefaultDataStorage()->GetSources( workingData, isNormalImage );
 
     if (possibleParents->size() > 0)
     {
       if (possibleParents->size() > 1)
       {
         // TODO visible warning for this rare case
         MITK_ERROR << "Selected binary image has multiple parents. Using arbitrary first one for segmentation.";
       }
 
       referenceData = (*possibleParents)[0];
     }
 
     NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( workingData );
     if ( searchIter == m_WorkingDataObserverTags.end() )
     {
       //MITK_INFO<<"Creating new observer";
       itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
       command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
       m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( workingData, workingData->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
       workingData->GetProperty("visible")->Modified();
 
       return;
     }
 
     if(workingData->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))))
     {
         //set comboBox to reference image
         disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
           this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
         m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(workingData) );
 
         connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
           this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
 
         // if Image and Surface are selected, enable button
         if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
           (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()) ||
           (!referenceData))
           m_Controls->CreateSegmentationFromSurface->setEnabled(false);
         else
           m_Controls->CreateSegmentationFromSurface->setEnabled(true);
 
         SetToolManagerSelection(referenceData, workingData);
         FireNodeSelected(workingData);
     }
     else
     {
         SetToolManagerSelection(NULL, NULL);
         FireNodeSelected(workingData);
     }
 
   }
-  else 
+  else
   {
     //set comboBox to reference image
-    disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ), 
+    disconnect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
       this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
     m_Controls->refImageSelector->setCurrentIndex( m_Controls->refImageSelector->Find(referenceData) );
 
-    connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ), 
+    connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
       this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
     // if Image and Surface are selected, enable button
     if ( (m_Controls->refImageSelector->GetSelectedNode().IsNull()) ||
       (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()) ||
       (!referenceData))
       m_Controls->CreateSegmentationFromSurface->setEnabled(false);
     else
       m_Controls->CreateSegmentationFromSurface->setEnabled(true);
 
     SetToolManagerSelection(referenceData, workingData);
 
     FireNodeSelected(referenceData);
   }
 }
 
 void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode *node)
 {
   //TODO renderWindow anders bestimmen, siehe CheckAlignment
   QmitkRenderWindow* selectedRenderWindow = 0;
   QmitkRenderWindow* RenderWindow1 =
     this->GetActiveStdMultiWidget()->GetRenderWindow1();
   QmitkRenderWindow* RenderWindow2 =
     this->GetActiveStdMultiWidget()->GetRenderWindow2();
   QmitkRenderWindow* RenderWindow3 =
     this->GetActiveStdMultiWidget()->GetRenderWindow3();
   QmitkRenderWindow* RenderWindow4 =
     this->GetActiveStdMultiWidget()->GetRenderWindow4();
   bool PlanarFigureInitializedWindow = false;
 
   // find initialized renderwindow
   if (node->GetBoolProperty("PlanarFigureInitializedWindow",
     PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
   {
     selectedRenderWindow = RenderWindow1;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     RenderWindow2->GetRenderer()))
   {
     selectedRenderWindow = RenderWindow2;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     RenderWindow3->GetRenderer()))
   {
     selectedRenderWindow = RenderWindow3;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     RenderWindow4->GetRenderer()))
   {
     selectedRenderWindow = RenderWindow4;
   }
 
   // make node visible
   if (selectedRenderWindow)
   {
     std::string nodeName = node->GetName();
     unsigned int t = nodeName.find_last_of(" ");
     unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
 
     // gets the context of the "Mitk" (Core) module (always has id 1)
     // TODO Workaround until CTL plugincontext is available
     mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
     // Workaround end
     mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
     //mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
 
     mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
     selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
     selectedRenderWindow->GetRenderer()->GetDisplayGeometry()->Fit();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 mitk::DataNode::Pointer QmitkSegmentationView::FindFirstRegularImage( std::vector<mitk::DataNode*> nodes )
 {
   if (nodes.empty()) return NULL;
 
   for(unsigned int i = 0; i < nodes.size(); ++i)
   {
     //mitk::DataNode::Pointer node = i.value()
     bool isImage(false);
     if (nodes.at(i)->GetData())
     {
       isImage = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData()) != NULL;
     }
 
     // make sure this is not a binary image
     bool isSegmentation(false);
     nodes.at(i)->GetBoolProperty("binary", isSegmentation);
 
     // return first proper mitk::Image
     if (isImage && !isSegmentation) return nodes.at(i);
   }
 
   return NULL;
 }
 
 
 mitk::DataNode::Pointer QmitkSegmentationView::FindFirstSegmentation( std::vector<mitk::DataNode*> nodes )
 {
   if (nodes.empty()) return NULL;
 
 
   for(unsigned int i = 0; i < nodes.size(); ++i)
   {
     bool isImage(false);
     if (nodes.at(i)->GetData())
     {
       isImage = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData()) != NULL;
     }
 
     bool isSegmentation(false);
     nodes.at(i)->GetBoolProperty("binary", isSegmentation);
 
     // return first proper binary mitk::Image
-    if (isImage && isSegmentation) 
+    if (isImage && isSegmentation)
     {
       return nodes.at(i);
     }
   }
 
   return NULL;
 }
 
 void QmitkSegmentationView::SetToolManagerSelection(const mitk::DataNode* referenceData, const mitk::DataNode* workingData)
 {
   // called as a result of new BlueBerry selections
   //   tells the ToolManager for manual segmentation about new selections
   //   updates GUI information about what the user should select
   mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
   toolManager->SetReferenceData(const_cast<mitk::DataNode*>(referenceData));
   toolManager->SetWorkingData(  const_cast<mitk::DataNode*>(workingData));
 
 
   // check original image
   m_Controls->btnNewSegmentation->setEnabled(referenceData != NULL);
   if (referenceData)
   {
     m_Controls->lblReferenceImageSelectionWarning->hide();
   }
   else
   {
     m_Controls->lblReferenceImageSelectionWarning->show();
     m_Controls->lblWorkingImageSelectionWarning->hide();
     m_Controls->lblSegImage->hide();
     m_Controls->lblSegmentation->hide();
   }
 
   //TODO remove statement
   // check, wheter reference image is aligned like render windows. Otherwise display a visible warning (because 2D tools will probably not work)
   CheckImageAlignment();
 
   // check segmentation
   if (referenceData)
-  { 
+  {
     if (!workingData)
     {
       m_Controls->lblWorkingImageSelectionWarning->show();
 
       if( m_Controls->widgetStack->currentIndex() == 0 )
       {
         m_Controls->lblSegImage->hide();
         m_Controls->lblSegmentation->hide();
       }
     }
     else
     {
       m_Controls->lblWorkingImageSelectionWarning->hide();
       this->FireNodeSelected(const_cast<mitk::DataNode*>(workingData));
 
       if( m_Controls->widgetStack->currentIndex() == 0 )
       {
         m_Controls->lblSegmentation->setText( workingData->GetName().c_str() );
         m_Controls->lblSegmentation->show();
         m_Controls->lblSegImage->show();
       }
     }
   }
 }
 
 //TODO remove function
 void QmitkSegmentationView::CheckImageAlignment()
 {
   bool wrongAlignment(true);
 
   mitk::DataNode::Pointer node = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
   if (node.IsNotNull())
   {
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
 
     if (image.IsNotNull() && m_MultiWidget)
     {
 
       wrongAlignment = !(    IsRenderWindowAligned(m_MultiWidget->GetRenderWindow1(), image )
         && IsRenderWindowAligned(m_MultiWidget->GetRenderWindow2(), image )
         && IsRenderWindowAligned(m_MultiWidget->GetRenderWindow3(), image )
         );
     }
   }
   m_Controls->lblAlignmentWarning->setVisible(wrongAlignment);
 }
 
 //TODO remove function
 bool QmitkSegmentationView::IsRenderWindowAligned(QmitkRenderWindow* renderWindow, mitk::Image* image)
 {
   if (!renderWindow) return false;
 
   // for all 2D renderwindows of m_MultiWidget check alignment
   mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( renderWindow->GetRenderer()->GetCurrentWorldGeometry2D() );
   if (displayPlane.IsNull()) return false;
 
   int affectedDimension(-1);
   int affectedSlice(-1);
   return mitk::SegTool2D::DetermineAffectedImageSlice( image, displayPlane, affectedDimension, affectedSlice );
 }
 
 //TODO remove function
 void QmitkSegmentationView::ForceDisplayPreferencesUponAllImages()
 {
   if (!m_Parent || !m_Parent->isVisible()) return;
 
   // check all images and segmentations in DataStorage:
   // (items in brackets are implicitly done by previous steps)
   // 1.
   //   if  a reference image is selected,
   //     show the reference image
   //     and hide all other images (orignal and segmentation),
   //     (and hide all segmentations of the other original images)
   //     and show all the reference's segmentations
   //   if no reference image is selected, do do nothing
   //
   // 2.
   //   if  a segmentation is selected,
   //     show it
   //     (and hide all all its siblings (childs of the same parent, incl, NULL parent))
   //   if no segmentation is selected, do nothing
 
   if (!m_Controls) return; // might happen on initialization (preferences loaded)
   mitk::DataNode::Pointer referenceData = m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetReferenceData(0);
   mitk::DataNode::Pointer workingData =   m_Controls->m_ManualToolSelectionBox->GetToolManager()->GetWorkingData(0);
 
   // 1.
   if (referenceData.IsNotNull())
   {
     // iterate all images
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
 
     mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDefaultDataStorage()->GetSubset( isImage );
     //mitk::DataStorage::SetOfObjects::ConstPointer allSegmentationChilds = this->GetDefaultDataStorage()->GetDerivations(referenceData, isImage );
     for ( mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin();
       iter != allImages->end();
       ++iter)
 
     {
       mitk::DataNode* node = *iter;
       // apply display preferences
       ApplyDisplayOptions(node);
 
       // set visibility
       if(!node->IsSelected() || (node->IsSelected() && !node->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")))))
         node->SetVisibility((node == referenceData) || node->IsSelected() );
     }
   }
 
   // 2.
   //if (workingData.IsNotNull() && !workingData->IsSelected())
   //{
   //  workingData->SetVisibility(true);
   //}
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
 {
   if (!node) return;
 
   bool isBinary(false);
   node->GetPropertyValue("binary", isBinary);
 
   if (isBinary)
   {
     node->SetProperty( "outline binary", mitk::BoolProperty::New( this->GetPreferences()->GetBool("draw outline", true)) );
     node->SetProperty( "outline width", mitk::FloatProperty::New( 2.0 ) );
     node->SetProperty( "opacity", mitk::FloatProperty::New( this->GetPreferences()->GetBool("draw outline", true) ? 1.0 : 0.3 ) );
     node->SetProperty( "volumerendering", mitk::BoolProperty::New( this->GetPreferences()->GetBool("volume rendering", false) ) );
   }
 }
 
 void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
 {
   // setup the basic GUI of this view
   m_Parent = parent;
 
   m_Controls = new Ui::QmitkSegmentationControls;
   m_Controls->setupUi(parent);
   m_Controls->lblWorkingImageSelectionWarning->hide();
   m_Controls->lblAlignmentWarning->hide();
   m_Controls->lblSegImage->hide();
   m_Controls->lblSegmentation->hide();
 
   m_Controls->refImageSelector->SetDataStorage(this->GetDefaultDataStorage());
   m_Controls->refImageSelector->SetPredicate(mitk::NodePredicateDataType::New("Image"));
 
   if( m_Controls->refImageSelector->GetSelectedNode().IsNotNull() )
     m_Controls->lblReferenceImageSelectionWarning->hide();
   else
     m_Controls->refImageSelector->hide();
 
 
   mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
   toolManager->SetDataStorage( *(this->GetDefaultDataStorage()) );
   assert ( toolManager );
 
   // all part of open source MITK
   m_Controls->m_ManualToolSelectionBox->SetGenerateAccelerators(true);
   m_Controls->m_ManualToolSelectionBox->SetToolGUIArea( m_Controls->m_ManualToolGUIContainer );
   m_Controls->m_ManualToolSelectionBox->SetDisplayedToolGroups("Add Subtract Paint Wipe 'Region Growing' Correction Fill Erase");
   m_Controls->m_ManualToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingData );
 
   // available only in the 3M application
   if ( !m_Controls->m_OrganToolSelectionBox->children().count() )
   {
     m_Controls->widgetStack->setItemEnabled( 1, false );
   }
   m_Controls->m_OrganToolSelectionBox->SetToolManager( *toolManager );
   m_Controls->m_OrganToolSelectionBox->SetToolGUIArea( m_Controls->m_OrganToolGUIContainer );
   m_Controls->m_OrganToolSelectionBox->SetDisplayedToolGroups("'Hippocampus left' 'Hippocampus right' 'Lung left' 'Lung right' 'Liver' 'Heart LV' 'Endocard LV' 'Epicard LV' 'Prostate'");
   m_Controls->m_OrganToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceData );
 
   // available only in the 3M application
   if ( !m_Controls->m_LesionToolSelectionBox->children().count() )
   {
     m_Controls->widgetStack->setItemEnabled( 2, false );
   }
   m_Controls->m_LesionToolSelectionBox->SetToolManager( *toolManager );
   m_Controls->m_LesionToolSelectionBox->SetToolGUIArea( m_Controls->m_LesionToolGUIContainer );
   m_Controls->m_LesionToolSelectionBox->SetDisplayedToolGroups("'Lymph Node'");
   m_Controls->m_LesionToolSelectionBox->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceData );
 
   toolManager->NewNodesGenerated +=
     mitk::MessageDelegate<QmitkSegmentationView>( this, &QmitkSegmentationView::NewNodesGenerated );          // update the list of segmentations
   toolManager->NewNodeObjectsGenerated +=
     mitk::MessageDelegate1<QmitkSegmentationView, mitk::ToolManager::DataVectorType*>( this, &QmitkSegmentationView::NewNodeObjectsGenerated );          // update the list of segmentations
 
   // create signal/slot connections
-  connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ), 
+  connect( m_Controls->refImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
     this, SLOT( OnComboBoxSelectionChanged( const mitk::DataNode* ) ) );
   connect( m_Controls->btnNewSegmentation, SIGNAL(clicked()), this, SLOT(CreateNewSegmentation()) );
   connect( m_Controls->CreateSegmentationFromSurface, SIGNAL(clicked()), this, SLOT(CreateSegmentationFromSurface()) );
   connect( m_Controls->widgetStack, SIGNAL(currentChanged(int)), this, SLOT(ToolboxStackPageChanged(int)) );
 
-  connect(m_Controls->MaskSurfaces,  SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ), 
+  connect(m_Controls->MaskSurfaces,  SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
     this, SLOT( OnSurfaceSelectionChanged( ) ) );
 
-  connect(m_Controls->MaskSurfaces,  SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ), 
+  connect(m_Controls->MaskSurfaces,  SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
     this, SLOT( OnSurfaceSelectionChanged( ) ) );
 
   connect(m_Controls->m_SlicesInterpolator, SIGNAL(SignalShowMarkerNodes(bool)), this, SLOT(OnShowMarkerNodes(bool)));
 
   m_Controls->MaskSurfaces->SetDataStorage(this->GetDefaultDataStorage());
   m_Controls->MaskSurfaces->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
 
   //// create helper class to provide context menus for segmentations in data manager
   // m_PostProcessing = new QmitkSegmentationPostProcessing(this->GetDefaultDataStorage(), this, m_Parent);
 
 }
 
 //void QmitkSegmentationView::OnPlaneModeChanged(int i)
 //{
 //  //if plane mode changes, disable all tools
 //  if (m_MultiWidget)
 //  {
 //    mitk::ToolManager* toolManager = m_Controls->m_ManualToolSelectionBox->GetToolManager();
 //
 //    if (toolManager)
 //    {
 //      if (toolManager->GetActiveToolID() >= 0)
 //      {
 //        toolManager->ActivateTool(-1);
 //      }
 //      else
 //      {
 //        m_MultiWidget->EnableNavigationControllerEventListening();
 //      }
 //    }
 //  }
 //}
 
 
 // ATTENTION some methods for handling the known list of (organ names, colors) are defined in QmitkSegmentationOrganNamesHandling.cpp
 
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 5d114f3800..e049f1327f 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
@@ -1,163 +1,166 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
-Copyright (c) German Cancer Research Center, 
+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 
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkSegmentationView_h
 #define QmitkSegmentationView_h
 
 #include "QmitkFunctionality.h"
 
 #include <berryIBerryPreferences.h>
 
 #include "ui_QmitkSegmentationControls.h"
 
 
 class QmitkRenderWindow;
 // class QmitkSegmentationPostProcessing;
 
 /**
  * \ingroup ToolManagerEtAl
  * \ingroup org_mitk_gui_qt_segmentation_internal
  * \warning Implementation of this class is split up into two .cpp files to make things more compact. Check both this file and QmitkSegmentationOrganNamesHandling.cpp
  */
 class QmitkSegmentationView : public QmitkFunctionality
 {
   Q_OBJECT
-  
+
 public:
-  
+
   QmitkSegmentationView();
 
   virtual ~QmitkSegmentationView();
 
   typedef std::map<mitk::DataNode*, unsigned long> NodeTagMapType;
 
   /*!
     \brief Invoked when the DataManager selection changed
     */
   virtual void OnSelectionChanged(mitk::DataNode* node);
   virtual void OnSelectionChanged(std::vector<mitk::DataNode*> nodes);
-  
+
   // reaction to new segmentations being created by segmentation tools
   void NewNodesGenerated();
   void NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType*);
-  
+
   // QmitkFunctionality's activate/deactivate
   virtual void Activated();
-  virtual void Deactivated();    
-  
+  virtual void Deactivated();
+  virtual void Visible();
+
   // QmitkFunctionality's changes regarding THE QmitkStdMultiWidget
   virtual void StdMultiWidgetAvailable(QmitkStdMultiWidget& stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
   virtual void StdMultiWidgetClosed(QmitkStdMultiWidget& stdMultiWidget);
-  
+
   // BlueBerry's notification about preference changes (e.g. from a dialog)
   virtual void OnPreferencesChanged(const berry::IBerryPreferences*);
-  
+
   // observer to mitk::RenderingManager's RenderingManagerViewsInitializedEvent event
   void RenderingManagerReinitialized(const itk::EventObject&);
-  
+
   // observer to mitk::SliceController's SliceRotation event
   void SliceRotation(const itk::EventObject&);
-  
+
   static const std::string VIEW_ID;
 
 protected slots:
-  
+
   void OnComboBoxSelectionChanged(const mitk::DataNode* node);
-  
+
   // reaction to the button "New segmentation"
   void CreateNewSegmentation();
-  
+
   // reaction to the button "New segmentation"
   void CreateSegmentationFromSurface();
-  
+
   // called when one of "Manual", "Organ", "Lesion" pages of the QToolbox is selected
   void ToolboxStackPageChanged(int id);
-  
+
   void OnSurfaceSelectionChanged();
-  
+
   //called when the checkbox Remember Contour Positions is selected/deselected
 
   void OnWorkingNodeVisibilityChanged();
 
   void OnShowMarkerNodes(bool);
 
 protected:
-  
+
   // a type for handling lists of DataNodes
   typedef std::vector<mitk::DataNode*> NodeList;
-  
+
   // set available multiwidget
   void SetMultiWidget(QmitkStdMultiWidget* multiWidget);
-  
+
   // actively query the current selection of data manager
   //void PullCurrentDataManagerSelection();
-  
+
   // reactions to selection events from data manager (and potential other senders)
   //void BlueBerrySelectionChanged(berry::IWorkbenchPart::Pointer sourcepart, berry::ISelection::ConstPointer selection);
   mitk::DataNode::Pointer FindFirstRegularImage( std::vector<mitk::DataNode*> nodes );
   mitk::DataNode::Pointer FindFirstSegmentation( std::vector<mitk::DataNode*> nodes );
-  
+
   // propagate BlueBerry selection to ToolManager for manual segmentation
   void SetToolManagerSelection(const mitk::DataNode* referenceData, const mitk::DataNode* workingData);
-  
+
   // checks if selected reference image is aligned with the slices stack orientation of the StdMultiWidget
   void CheckImageAlignment();
-  
+
   // checks if given render window aligns with the slices of given image
   bool IsRenderWindowAligned(QmitkRenderWindow* renderWindow, mitk::Image* image);
-  
+
   // make sure all images/segmentations look as selected by the users in this view's preferences
   void ForceDisplayPreferencesUponAllImages();
-  
+
   // decorates a DataNode according to the user preference settings
   void ApplyDisplayOptions(mitk::DataNode* node);
-  
+
   // GUI setup
   void CreateQtPartControl(QWidget* parent);
-  
+
   // handling of a list of known (organ name, organ color) combination
   // ATTENTION these methods are defined in QmitkSegmentationOrganNamesHandling.cpp
   QStringList GetDefaultOrganColorString();
   void UpdateOrganList(QStringList& organColors, const QString& organname, mitk::Color colorname);
   void AppendToOrganList(QStringList& organColors, const QString& organname, int r, int g, int b);
-  
+
   // 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 NodeRemoved(const mitk::DataNode* node);
 
   // the Qt parent of our GUI (NOT of this object)
   QWidget* m_Parent;
-  
+
   // our GUI
   Ui::QmitkSegmentationControls * m_Controls;
-  
+
   // THE currently existing QmitkStdMultiWidget
   QmitkStdMultiWidget * m_MultiWidget;
-  
+
   // QmitkSegmentationPostProcessing* m_PostProcessing;
-  
+
   unsigned long m_RenderingManagerObserverTag;
   unsigned long m_SlicesRotationObserverTag1;
   unsigned long m_SlicesRotationObserverTag2;
   unsigned long m_VisibilityChangedObserverTag;
 
+  bool m_DataSelectionChanged;
+
   NodeTagMapType  m_WorkingDataObserverTags;
 };
 
 #endif /*QMITKsegmentationVIEW_H_*/
 
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualizationUserManual.dox b/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualizationUserManual.dox
index 2972552f37..dbe3b81009 100644
--- a/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualizationUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualizationUserManual.dox
@@ -1,150 +1,150 @@
 /**
-\page org_mitk_views_volumevisualization The Volume Visualization Module
+\page org_mitk_views_volumevisualization The Volume Visualization Plugin
 
-\image html icon.png "Icon of the Module"
+\image html icon.png "Icon of the Plugin"
 
 Available sections:
 <ul>
 <li> \ref QVV_Overview
 <li> \ref QVV_EnableVRPage
 <li> \ref QVV_PresetPage
 <li> \ref QVV_ThresholdBell
 <li> \ref QVV_Editing
 </ul>
 
 \section QVV_Overview Overview
 
-The <b> Volume Visualization Module </b> is a basic tool for visualizing three dimensional medical images. 
+The <b> Volume Visualization Plugin </b> is a basic tool for visualizing three dimensional medical images. 
 MITK provides generic transfer function presets for medical CT data. 
 These functions, that map the gray-value to color and opacity, can be interactively edited. 
 Additionally, there are controls to quickly generate common used transfer function shapes 
 like the threshold and bell curve to help identify a range of grey-values.
 
 \image html vroverview.png ""
 
 \section QVV_EnableVRPage Enable Volume Rendering
 
 \subsection QVV_LoadingImage Loading an image into the application
 
 Load an image into the application by
 
 <ul>
 <li> dragging a file into the application window.
 <li> selecting file / load from the menu.
 </ul>
 
 Volume Visualization imposes following restrictions on images:
 
 <ul>
 <li> It has to be a 3D-Image Scalar image, that means a normal CT or MRT.
 <li> 3D+T are supported for rendering, but the histograms are not computed.
 <li> Also be aware that volume visualization requires a huge amount of memory. 
      Very large images may not work, unless you use the 64bit version.
 </ul>
 
 \subsection QVV_EnableVR Enable Volumerendering
 
 \image html checkboxen.png ""
 
 Select an image in datamanager and click on the checkbox left of "Volumerendering".
 Please be patient, while the image is prepared for rendering, which can take up to a half minute.
 
 \subsection QVV_LODGPU The LOD & GPU checkboxes
 
 Volume Rendering requires a lot of computing resources including processor, memory and graphics card.
 
 To run volume rendering on smaller platforms,
 enable the LOD checkbox (level-of-detail rendering).
 Level-of-detail first renders a lower quality preview to increase interactivity.
 If the user stops to interact a normal quality rendering is issued.
 
 The GPU checkbox tries to use computing resources on the graphics card to accelerate volume rendering.
 It requires a powerful graphics card and OpenGL hardware support for shaders, but achieves much higher frame rates than software-rendering.
 
 \section QVV_PresetPage Applying premade presets
 
 \subsection QVV_Preset Internal presets
 
 There are some internal presets given, that can be used with normal CT data (given in Houndsfield units).
 A large set of medical data has been tested with that presets, but it may not suit on some special cases.
 
 Click on the "Preset" tab for using internal or custom presets.
 
 \image html mitkInternalPresets.png ""
 
 <ul>
 <li> "CT Generic" is the default transferfunction that is first applied.  
 <li> "CT Black&White" does not use any colors, as it may be distracting on some data.
 <li> "CT Cardiac" tries to increase detail on CTs from the heart. 
 <li> "CT Bone" emphasizes bones and shows other areas more transparent. 
 <li> "CT Bone (Gradient)" is like "CT Bone", but shows  from other organs only the surface by using the gradient.
 <li> "MR Generic" is the default transferfunction that we use on MRT data (which is not normalized like CT data).  
 <li> "CT Thorax small" tries to increase detail.  
 <li> "CT Thorax large" tries to increase detail.  
 </ul>
 
 \subsection QVV_CustomPreset Saving and loading custom presets
 
 After creating or editing a transferfunction (see \ref QVV_Editing or \ref QVV_ThresholdBell), 
 the custom transferfunction can be stored and later retrieved on the filesystem.
 Click "Save" (respectively "Load") button to save (load) the threshold-, color- and gradient function combined in a single .xml file.
 
 \section QVV_ThresholdBell Interactively create transferfunctions
 
 Beside the possibility to directly edit the transferfunctions (\ref QVV_Editing),
 a one-click generation of two commonly known shapes is given.
 
 Both generators have two parameters, that can be modified by first clicking on the cross and then moving the mouse up/down and left/right.
 
 The first parameter "center" (controlled by horizontal movement of the mouse) specifies the gravalue where the center of the shape will be located.
 
 The second parameter "width" (controlled by vertical movement of the mouse) specifies the width (or steepness) of the shape.
 
 \subsection Threshold
 
 Click on the "Threshold" tab to active the threshold function generator.
 \image html threshold.png ""
 A threshold shape begins with zero and raises to one across the "center" parameter. Lower widths results in steeper threshold functions.
 
 \subsection Bell
 
 Click on the "Bell" tab to active the threshold function generator.
 \image html bell.png ""
 A threshold shape begins with zero and raises to one at the "center" parameter and the lowers agains to zero. The "width" parameter correspondens to the width of the bell.
 
 \section QVV_Editing Customize transferfunctions in detail
 
 \subsection QVV_Navigate Choosing grayvalue interval to edit
 
 \image html slider.png ""
 To navigate across the grayvalue range or to zoom in some ranges use the "range"-slider.
 
 All three function editors have in common following:
 
 <ul>
 <li> By left-clicking a new point is added.
 <li> By right-clicking a point is deleted.
 <li> By left-clicking and holding, an exisiting point can be dragged.
 <li> By pressing arrow keys, the currently selected point is moved.
 <li> By pressing the "DELETE" key, the currently selected point is deleted.
 <li> Between points the transferfunctions are linear interpolated.
 </ul>
 
 There are three transferfunctions to customize:
 
 \subsection QVV_GO Grayvalue -> Opacity
 
 \image html opacity.png "grayvalues will be mapped to opacity." 
 An opacity of 0 means total transparent, an opacity of 1 means total opaque.  
 
 \subsection QVV_GC Grayvalue -> Color
 
 \image html color.png "grayvalues will be mapped to color." 
 The color transferfunction editor also allows by double-clicking a point to change its color.
 
 \subsection QVV_GGO Grayvalue and Gradient -> Opacity
 
 \image html gradient.png ""
 Here the influence of the gradient is controllable at specific grayvalues. 
 
 */
diff --git a/mitkVersion.h.in b/mitkVersion.h.in
index 8047bcae0d..4849c4876a 100644
--- a/mitkVersion.h.in
+++ b/mitkVersion.h.in
@@ -1,13 +1,13 @@
 /*
   mitkVersion.h
   this file is generated. Do not change!
 */
 
 #define MITK_VERSION_MAJOR @MITK_VERSION_MAJOR@
 #define MITK_VERSION_MINOR @MITK_VERSION_MINOR@
 #define MITK_VERSION_PATCH @MITK_VERSION_PATCH@
 #define MITK_VERSION_STRING "@MITK_VERSION_STRING@"
 
 #define MITK_REVISION "@MITK_REVISION_ID@"
 #define MITK_REVISION_NAME "@MITK_REVISION_NAME@"
-
+#define MITK_REVISION_DESC "@MITK_REVISION_DESC@"