diff --git a/CMakeLists.txt b/CMakeLists.txt
index fedc42f..93633ea 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,298 +1,294 @@
 #-----------------------------------------------------------------------------
 # This is the root RTToolbox CMakeList file.
 #-----------------------------------------------------------------------------
 PROJECT(RTToolbox)
 
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8.11.2)
 IF(CMAKE_BACKWARDS_COMPATIBILITY GREATER 2.8.11.2)
   SET(CMAKE_BACKWARDS_COMPATIBILITY 2.8.11.2 CACHE STRING "Latest version of CMake when this project was released." FORCE)
 ENDIF(CMAKE_BACKWARDS_COMPATIBILITY GREATER 2.8.11.2)
 
 # RTToolbox version number.
 SET(RTToolbox_VERSION_MAJOR "4")
 SET(RTToolbox_VERSION_MINOR "1")
 SET(RTToolbox_VERSION_PATCH "1")
 
 # Version string should not include patch level.  The major.minor is
 # enough to distinguish available features of the toolbox.
 SET(RTToolbox_VERSION_STRING "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}")
 SET(RTToolbox_FULL_VERSION_STRING "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}.${RTToolbox_VERSION_PATCH}")
 
 # default build type
 SET(CMAKE_BUILD_TYPE Release)
 
 MARK_AS_ADVANCED(BUILD_SHARED_LIBS)
 
 IF (WIN32)
 	IF (MSVC_VERSION LESS 1600)
 		MESSAGE(FATAL_ERROR "RTToolbox requires at least Visual Studio 2010.")
 	ENDIF(MSVC_VERSION LESS 1600)
 	add_definitions(-D_SCL_SECURE_NO_WARNINGS)
 ELSE (WIN32)
 	IF (CMAKE_COMPILER_IS_GNUCC)
 		IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 5.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 5.0)
 			MESSAGE(AUTHOR_WARNING "RTToolbox was only tested with GCC 4.6 and GCC 4.9. You are using GCC " ${CMAKE_CXX_COMPILER_VERSION} ". This compiler version might not work.")
 		ENDIF()
 	ENDIF()
 ENDIF(WIN32)
 
 
 IF (NOT (CMAKE_MAJOR_VERSION LESS 3))
 	IF(COMMAND CMAKE_POLICY)
 	  # Enable old CMake behaviour when dealing with export_library_dependencies().
 	  # This is necessary to avoid warnings in CMake versions
 	  # greater than 3.0
 	  # See http://www.cmake.org/cmake/help/v3.0/policy/CMP0033.html
 	  CMAKE_POLICY(SET CMP0033 OLD)
 	ENDIF(COMMAND CMAKE_POLICY)
 ENDIF()
 
 #-----------------------------------------------------------------------------
 # CMake Function(s) and Macro(s)
 #-----------------------------------------------------------------------------
 
 include(cmake/MacroParseArguments.cmake)
 include(cmake/rttbMacroCreateModuleConf.cmake)
 include(cmake/rttbMacroCreateModule.cmake)
 include(cmake/rttbMacroCreateApplication.cmake)
 include(cmake/rttbMacroCheckModule.cmake)
 include(cmake/rttbMacroUseModule.cmake)
 include(cmake/rttbMacroCreateTestModule.cmake)
 include(cmake/rttbFunctionOrganizeSources.cmake)
 include(cmake/rttbMacroCreateApplicationTests.cmake)
 
 #-----------------------------------------------------------------------------
 # Basis config RTTB module infrastructure
 #-----------------------------------------------------------------------------
 
 set(RTTB_MODULES_CONF_DIR ${RTToolbox_BINARY_DIR}/modulesConf CACHE INTERNAL "Modules Conf")
 set(RTTB_MODULES_PACKAGE_DEPENDS_DIR ${RTToolbox_SOURCE_DIR}/cmake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${RTTB_MODULES_PACKAGE_DEPENDS_DIR})
 
 #-----------------------------------------------------------------------------
 # Testing setup
 # Configure Dart testing support.  This should be done before any
 # MESSAGE(FATAL_ERROR ...) commands are invoked.
 #-----------------------------------------------------------------------------
 SET(CTEST_NEW_FORMAT 1)
 INCLUDE(CTest)
 ENABLE_TESTING()
 
 IF(BUILD_TESTING)
   CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/RemoveTemporaryFiles.cmake.in
     ${RTToolbox_BINARY_DIR}/cmake/RemoveTemporaryFiles.cmake @ONLY IMMEDIATE)
   CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/rttbSampleBuildTest.cmake.in
     ${RTToolbox_BINARY_DIR}/cmake/rttbSampleBuildTest.cmake @ONLY)
   CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/CTestCustom.ctest.in
     ${RTToolbox_BINARY_DIR}/cmake/CTestCustom.ctest @ONLY)
   FILE(WRITE ${RTToolbox_BINARY_DIR}/CTestCustom.cmake
     "INCLUDE(\"${RTToolbox_BINARY_DIR}/cmake/CTestCustom.ctest\")\n")
 
   SET(BUILDNAME "${BUILDNAME}" CACHE STRING "Name of build on the dashboard")
   MARK_AS_ADVANCED(BUILDNAME)
 ENDIF(BUILD_TESTING)
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 IF(NOT LIBRARY_OUTPUT_PATH)
   SET (LIBRARY_OUTPUT_PATH ${RTToolbox_BINARY_DIR}/bin CACHE PATH "Single output directory for building all libraries.")
 ENDIF(NOT LIBRARY_OUTPUT_PATH)
 IF(NOT EXECUTABLE_OUTPUT_PATH)
   SET (EXECUTABLE_OUTPUT_PATH ${RTToolbox_BINARY_DIR}/bin CACHE PATH "Single output directory for building all executables.")
 ENDIF(NOT EXECUTABLE_OUTPUT_PATH)
 MARK_AS_ADVANCED(EXECUTABLE_OUTPUT_PATH LIBRARY_OUTPUT_PATH)
 
 
 MARK_AS_ADVANCED(LIBRARY_OUTPUT_PATH EXECUTABLE_OUTPUT_PATH)
 SET(RTToolbox_LIBRARY_PATH "${LIBRARY_OUTPUT_PATH}")
 SET(RTToolbox_EXECUTABLE_PATH "${EXECUTABLE_OUTPUT_PATH}")
 
 #-----------------------------------------------------------------------------
 # Find Doxygen.
 #-----------------------------------------------------------------------------
 FIND_PROGRAM(DOXYGEN_EXECUTABLE "doxygen")
 
 #-----------------------------------------------------------------------------
 # Installation vars.
 # RTToolbox_INSTALL_BIN_DIR          - binary dir (executables)
 # RTToolbox_INSTALL_LIB_DIR          - library dir (libs)
 # RTToolbox_INSTALL_INCLUDE_DIR      - include dir (headers)
 # RTToolbox_INSTALL_NO_DEVELOPMENT   - do not install development files
 # RTToolbox_INSTALL_NO_RUNTIME       - do not install runtime files
 # RTToolbox_INSTALL_NO_DOCUMENTATION - do not install documentation files
 # Remark: needs directory are stored with no leading slash (CMake 2.4 and newer)
 #-----------------------------------------------------------------------------
 
 IF(NOT RTTOOLBOX_INSTALL_BIN_DIR)
   SET(RTTOOLBOX_INSTALL_BIN_DIR "bin")
 ENDIF(NOT RTTOOLBOX_INSTALL_BIN_DIR)
 
 IF(NOT RTTOOLBOX_INSTALL_LIB_DIR)
   SET(RTTOOLBOX_INSTALL_LIB_DIR "lib")
 ENDIF(NOT RTTOOLBOX_INSTALL_LIB_DIR)
 
 IF(NOT RTTOOLBOX_INSTALL_PACKAGE_DIR)
   SET(RTTOOLBOX_INSTALL_PACKAGE_DIR "lib")
 ENDIF(NOT RTTOOLBOX_INSTALL_PACKAGE_DIR)
 
 IF(NOT RTTOOLBOX_INSTALL_INCLUDE_DIR)
   SET(RTTOOLBOX_INSTALL_INCLUDE_DIR "include")
 ENDIF(NOT RTTOOLBOX_INSTALL_INCLUDE_DIR)
 
 IF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
   SET(RTTOOLBOX_INSTALL_NO_DEVELOPMENT 0)
 ENDIF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
 
 IF(NOT RTTOOLBOX_INSTALL_NO_RUNTIME)
   SET(RTTOOLBOX_INSTALL_NO_RUNTIME 0)
 ENDIF(NOT RTTOOLBOX_INSTALL_NO_RUNTIME)
 
 IF(NOT RTTOOLBOX_INSTALL_NO_DOCUMENTATION)
   SET(RTTOOLBOX_INSTALL_NO_DOCUMENTATION 0)
 ENDIF(NOT RTTOOLBOX_INSTALL_NO_DOCUMENTATION)
 
 SET(RTTOOLBOX_INSTALL_NO_LIBRARIES)
 IF(RTTOOLBOX_BUILD_SHARED_LIBS)
   IF(RTTOOLBOX_INSTALL_NO_RUNTIME AND RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
     SET(RTTOOLBOX_INSTALL_NO_LIBRARIES 1)
   ENDIF(RTTOOLBOX_INSTALL_NO_RUNTIME AND RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
 ELSE(RTTOOLBOX_BUILD_SHARED_LIBS)
   IF(RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
     SET(RTTOOLBOX_INSTALL_NO_LIBRARIES 1)
   ENDIF(RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
 ENDIF(RTTOOLBOX_BUILD_SHARED_LIBS)
 
 # set RTToolbox_DIR so it can be used by subprojects
 SET(RTToolbox_DIR "${CMAKE_BINARY_DIR}" CACHE INTERNAL "RTToolbox dir to be used by subprojects")
 
 #-----------------------------------------------------------------------------
 # DCMTK MT-Flag treat
 #-----------------------------------------------------------------------------
 option(RTTB_DCMTK_COMPLIANCE_ENFORCE_MT "This enforces the whole RTToolbox to be compiled with /MT,/MTd to be compliant with DCMTK" OFF)
 
 string(FIND ${CMAKE_GENERATOR} "Visual Studio" RTTB_VS_USED)
 
 if(RTTB_DCMTK_COMPLIANCE_ENFORCE_MT AND RTTB_VS_USED EQUAL 0)
   message(STATUS "Enforce DCMTK compliance: /MT and /MTd flags are used")
 
   string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG})
   message(STATUS "CMAKE_C_FLAGS_DEBUG set to: ${CMAKE_C_FLAGS_DEBUG}")
   string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELEASE})
   message(STATUS "CMAKE_C_FLAGS_RELEASE set to: ${CMAKE_C_FLAGS_RELEASE}")
   string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_MINSIZEREL ${CMAKE_C_FLAGS_MINSIZEREL})
   message(STATUS "CMAKE_C_FLAGS_MINSIZEREL set to: ${CMAKE_C_FLAGS_MINSIZEREL}")
   string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELWITHDEBINFO ${CMAKE_C_FLAGS_RELWITHDEBINFO})
   message(STATUS "CMAKE_C_FLAGS_RELWITHDEBINFO set to: ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
 
   string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
   message(STATUS "CMAKE_CXX_FLAGS_DEBUG set to: ${CMAKE_CXX_FLAGS_DEBUG}")
   string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE})
   message(STATUS "CMAKE_CXX_FLAGS_RELEASE set to: ${CMAKE_CXX_FLAGS_RELEASE}")
   string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_MINSIZEREL ${CMAKE_CXX_FLAGS_MINSIZEREL})
   message(STATUS "CMAKE_CXX_FLAGS_MINSIZEREL set to: ${CMAKE_CXX_FLAGS_MINSIZEREL}")
   string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})
   message(STATUS "CMAKE_CXX_FLAGS_RELWITHDEBINFO set to: ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")  
 endif()
 
 #-----------------------------------------------------------------------------
 # Advanced RTToolbox configuration
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # RTToolbox build configuration options.
 IF (WIN32)
   OPTION(BUILD_SHARED_LIBS "Build RTToolbox with shared libraries." OFF)
 ELSE (WIN32)
   OPTION(BUILD_SHARED_LIBS "Build RTToolbox with shared libraries." ON)
 ENDIF (WIN32)
 
-IF(BUILD_SHARED_LIBS)
-  IF(WIN32)
-  MESSAGE(FATAL_ERROR "RTToolbox currently does not support a dynamic build on Windows. We are working on that...")
-  ENDIF(WIN32)
-ELSE(BUILD_SHARED_LIBS)
+IF(NOT BUILD_SHARED_LIBS)
   IF(UNIX)
   MESSAGE(FATAL_ERROR "RTToolbox currently does not support a static build on unix like systems. We are working on that...")
   ENDIF(UNIX)
-ENDIF(BUILD_SHARED_LIBS)
+ENDIF(NOT BUILD_SHARED_LIBS)
 
 SET(RTToolbox_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
 
 IF(NOT RTToolbox_NO_LIBRARY_VERSION)
   # This setting of SOVERSION assumes that any API change
   # will increment either the minor or major version number of RTToolbox.
   SET(RTToolbox_LIBRARY_PROPERTIES 
       VERSION   "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}.${RTToolbox_VERSION_PATCH}"
       SOVERSION "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}"
      )
 ENDIF(NOT RTToolbox_NO_LIBRARY_VERSION)
 
 #-----------------------------------------------------------------------------
 # Configure files with settings for use by the build.
 # 
 #-----------------------------------------------------------------------------
 
 CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/RTToolboxConfigure.h.in 
   ${RTToolbox_BINARY_DIR}/RTToolboxConfigure.h)
   
 IF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
   INSTALL(FILES ${RTToolbox_BINARY_DIR}/RTToolboxConfigure.h
     DESTINATION ${RTTOOLBOX_INSTALL_INCLUDE_DIR}
     COMPONENT Development)
 ENDIF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
 
 #-----------------------------------------------------------------------------
 # The entire RTToolbox tree should use the same include path
 #-----------------------------------------------------------------------------
 
 #Default include dir. Others dirs will be defined by activated subprojects
 INCLUDE_DIRECTORIES(${RTToolbox_BINARY_DIR})
 
 LINK_DIRECTORIES(${LIBARY_OUTPUT_PATH})
 
 #Prepare the correct target information export by the subprojects
 SET(RTToolbox_TARGETS_FILE "${RTToolbox_BINARY_DIR}/RTToolboxTargets.cmake")
 FILE(WRITE ${RTToolbox_TARGETS_FILE} "# Generated by CMake, do not edit!")
 
 #-----------------------------------------------------------------------------
 # Dispatch the build into the proper subdirectories.
 #-----------------------------------------------------------------------------
 
 MESSAGE (STATUS "generating Project RTToolbox")
 ADD_SUBDIRECTORY (code)
 ADD_SUBDIRECTORY (demoapps)
 
 IF (BUILD_TESTING)
   ADD_SUBDIRECTORY (testing)
 ENDIF (BUILD_TESTING)
 
 ADD_SUBDIRECTORY (documentation)
 
 #-----------------------------------------------------------------------------
 # Help other projects use RTToolbox.
 #-----------------------------------------------------------------------------
 
 EXPORT(PACKAGE RTToolbox)
 
 # Copy the UseRTToolbox.cmake file to the binary tree for backward compatability.
 CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/UseRTToolbox.cmake.in
                ${RTToolbox_BINARY_DIR}/UseRTToolbox.cmake COPYONLY IMMEDIATE)
 
 # Save library dependencies.
 EXPORT_LIBRARY_DEPENDENCIES(${RTToolbox_BINARY_DIR}/RTToolboxLibraryDepends.cmake)
 
 # Create the RTToolboxConfig.cmake file containing the RTToolbox configuration.
 INCLUDE (${RTToolbox_SOURCE_DIR}/rttbGenerateRTToolboxConfig.cmake)
 
 IF(NOT RTToolbox_INSTALL_NO_DEVELOPMENT)
   INSTALL(FILES
     ${RTToolbox_BINARY_DIR}/RTToolboxConfig.cmake
     ${RTToolbox_BINARY_DIR}/RTToolboxTargets.cmake
     ${RTToolbox_BINARY_DIR}/RTToolboxLibraryDepends.cmake
     ${RTToolbox_BINARY_DIR}/UseRTToolbox.cmake
     DESTINATION ${RTTOOLBOX_INSTALL_PACKAGE_DIR}
     COMPONENT Development
     )
 ENDIF(NOT RTToolbox_INSTALL_NO_DEVELOPMENT)
diff --git a/cmake/PackageDepends/RTTB_BoostBinaries_Config.cmake b/cmake/PackageDepends/RTTB_BoostBinaries_Config.cmake
index 0f8f727..239183e 100644
--- a/cmake/PackageDepends/RTTB_BoostBinaries_Config.cmake
+++ b/cmake/PackageDepends/RTTB_BoostBinaries_Config.cmake
@@ -1,29 +1,34 @@
 IF(NOT BoostBinaries_FOUND)
 
   IF(DEFINED Boost_INCLUDE_DIR)
     IF(NOT IS_ABSOLUTE ${Boost_INCLUDE_DIR})
       SET(Boost_INCLUDE_DIR "${RTToolbox_BINARY_DIR}/${Boost_INCLUDE_DIR}")
     ENDIF(NOT IS_ABSOLUTE ${Boost_INCLUDE_DIR})
   ENDIF(DEFINED Boost_INCLUDE_DIR)
-	
-  IF(BUILD_SHARED_LIBS)
+
+  IF(NOT DEFINED RTTB_USE_MITK_BOOST)
+    OPTION(RTTB_USE_MITK_BOOST "RTTB should use a boost which is available in the MITK superbuild external projects structure." OFF)
+    MARK_AS_ADVANCED(RTTB_USE_MITK_BOOST)
+  ENDIF(NOT DEFINED RTTB_USE_MITK_BOOST)
+  
+  IF(BUILD_SHARED_LIBS OR RTTB_USE_MITK_BOOST)
     SET(Boost_USE_STATIC_LIBS OFF)
-  ELSE(BUILD_SHARED_LIBS)
+	ADD_DEFINITIONS(-DBOOST_ALL_DYN_LINK)
+  ELSE(BUILD_SHARED_LIBS OR RTTB_USE_MITK_BOOST)
     SET(Boost_USE_STATIC_LIBS ON)
-  ENDIF(BUILD_SHARED_LIBS)
+  ENDIF(BUILD_SHARED_LIBS OR RTTB_USE_MITK_BOOST)
 
   SET(BOOST_MIN_VERSION "1.56.0")
-  FIND_PACKAGE(Boost ${BOOST_MIN_VERSION} REQUIRED COMPONENTS filesystem regex program_options system)
-
+  FIND_PACKAGE(Boost ${BOOST_MIN_VERSION} REQUIRED COMPONENTS filesystem regex system ${RTTB_Boost_ADDITIONAL_COMPONENT})
   LIST(APPEND ALL_INCLUDE_DIRECTORIES ${Boost_INCLUDE_DIRS})
   LIST(APPEND ALL_LIBRARIES ${Boost_LIBRARIES})
   link_directories(${Boost_LIBRARY_DIRS})
 	
   MARK_AS_ADVANCED(CLEAR Boost_INCLUDE_DIR)
 
   SET(BoostBinaries_FOUND TRUE)
 
 ENDIF(NOT BoostBinaries_FOUND)
 
 
 
diff --git a/cmake/PackageDepends/RTTB_DCMTK_Config.cmake b/cmake/PackageDepends/RTTB_DCMTK_Config.cmake
index 50d13d2..bd30a9e 100644
--- a/cmake/PackageDepends/RTTB_DCMTK_Config.cmake
+++ b/cmake/PackageDepends/RTTB_DCMTK_Config.cmake
@@ -1,218 +1,230 @@
 #-----------------------------------------------------------------------------
 # Find DCMTK
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # This part is based on the findDCMTK of CMake 2.8.8
 # it was patched because:
 # 1. the find_library statement had an incomplete set
 #    of search paths. If building DCMTK with Visual
 #    Studio the libs are to be found in /lib/release
 #    or /lib/debug
 # 2. the module DCMRT was not included (but needed by RTToolbox)
 #
 IF(DEFINED DCMTK_DIR)
   IF(NOT IS_ABSOLUTE ${DCMTK_DIR})
     SET(DCMTK_DIR "${RTToolbox_BINARY_DIR}/${DCMTK_DIR}")
   ENDIF(NOT IS_ABSOLUTE ${DCMTK_DIR})
 ENDIF(DEFINED DCMTK_DIR)
 
 if(NOT DCMTK_FOUND AND NOT DCMTK_DIR)
 	IF (NOT WIN32)
 		set(DCMTK_DIR "/usr/include/dcmtk/")
 	ENDIF(NOT WIN32)
 endif()
 
 #ensure that we always have the variable as cache, independent from
 #setting it via gui or command line
 set(DCMTK_DIR ${DCMTK_DIR} CACHE PATH "Root of DCMTK tree.")
 
 IF(DEFINED DCMTK_SOURCE_DIR)
   IF(NOT IS_ABSOLUTE ${DCMTK_SOURCE_DIR})
     SET(DCMTK_SOURCE_DIR "${RTToolbox_BINARY_DIR}/${DCMTK_SOURCE_DIR}")
   ENDIF(NOT IS_ABSOLUTE ${DCMTK_SOURCE_DIR})
 ENDIF(DEFINED DCMTK_SOURCE_DIR)
 
 if(NOT DCMTK_FOUND AND NOT DCMTK_SOURCE_DIR)
   set(DCMTK_SOURCE_DIR ${DCMTK_DIR})
 endif()
 
 #ensure that we always have the variable as cache, independent from
 #setting it via gui or command line
 set(DCMTK_SOURCE_DIR ${DCMTK_SOURCE_DIR} CACHE PATH "Root of DCMTK tree.")
 
+IF(NOT DEFINED RTTB_USE_MITK_DCMTK)
+  OPTION(RTTB_USE_MITK_DCMTK "RTTB should use a DCMTK which is available in the MITK superbuild external projects structure." OFF)
+  MARK_AS_ADVANCED(RTTB_USE_MITK_DCMTK)
+ENDIF(NOT DEFINED RTTB_USE_MITK_DCMTK)
+
 OPTION(RTTB_USE_ML_DCMTK "RTTB should use a DCMTK which is available in the MeVisLab package structure." OFF)
 MARK_AS_ADVANCED(RTTB_USE_ML_DCMTK)
 
 
 if(NOT DCMTK_FOUND)
   set(DCMTK_FOUND True)
   
   set(DCMTK_DEBUG_LIB_SEARCH_PATH 
     ${DCMTK_DIR}/${lib}/libsrc/Debug
     ${DCMTK_DIR}/${lib}/Debug
     ${DCMTK_DIR}/lib/Debug
 	)
   
   set(DCMTK_LIB_SEARCH_PATH 
     ${DCMTK_DIR}/${lib}/libsrc
     ${DCMTK_DIR}/${lib}/libsrc/Release
     ${DCMTK_DIR}/${lib}/Release
     ${DCMTK_DIR}/lib/Release
     ${DCMTK_DIR}/lib
 	)
 
   set(DCMTK_LIB_SEARCH_NAMES
     dcmdata
     dcmimage
     dcmimgle
     dcmjpeg
     dcmnet
     dcmpstat
     dcmqrdb
     dcmdsig
     dcmsr
     dcmtls
     dcmrt
     ijg12
     ijg16
     ijg8
     ofstd
     oflog
 	)
 
   if(${RTTB_USE_ML_DCMTK})
     set(DCMTK_DEBUG_LIB_SEARCH_PATH ${DCMTK_DIR}/lib )  
     set(DCMTK_LIB_SEARCH_PATH ${DCMTK_DIR}/lib )  
     set(DCMTK_LIB_SEARCH_NAMES ${DCMTK_LIB_SEARCH_NAMES} zlib)
   endif(${RTTB_USE_ML_DCMTK})
 
 
 
 foreach(lib ${DCMTK_LIB_SEARCH_NAMES})
 	
-  if(${RTTB_USE_ML_DCMTK})
-    find_library(DCMTK_${lib}_DEBUG_LIBRARY
-      ${lib}_d
-      PATHS ${DCMTK_DEBUG_LIB_SEARCH_PATH})
-  else(${RTTB_USE_ML_DCMTK})
-    find_library(DCMTK_${lib}_DEBUG_LIBRARY
-      ${lib}
-      PATHS ${DCMTK_DEBUG_LIB_SEARCH_PATH})
-  endif(${RTTB_USE_ML_DCMTK})
-
+  set(debuglib ${lib})
+  
+  if(${RTTB_USE_MITK_DCMTK})
+    set(debuglib ${lib}d)
+  elseif(${RTTB_USE_ML_DCMTK})
+    set(debuglib ${lib}_d)
+  endif(${RTTB_USE_MITK_DCMTK})
+
+  find_library(DCMTK_${lib}_DEBUG_LIBRARY
+    ${debuglib}
+    PATHS ${DCMTK_DEBUG_LIB_SEARCH_PATH})
+  
   find_library(DCMTK_${lib}_LIBRARY
     ${lib}
     PATHS  ${DCMTK_LIB_SEARCH_PATH})	
 	
   if((${UNIX}) AND (NOT DCMTK_${lib}_DEBUG_LIBRARY))
     set(DCMTK_${lib}_DEBUG_LIBRARY ${DCMTK_${lib}_LIBRARY} CACHE PATH "Path to a library" FORCE)
   endif((${UNIX}) AND (NOT DCMTK_${lib}_DEBUG_LIBRARY))
 
   mark_as_advanced(DCMTK_${lib}_LIBRARY)
   mark_as_advanced(DCMTK_${lib}_DEBUG_LIBRARY)
 	
   add_library(${lib} STATIC IMPORTED)
   set_target_properties(${lib} PROPERTIES IMPORTED_LOCATION ${DCMTK_${lib}_LIBRARY} IMPORTED_LOCATION_DEBUG ${DCMTK_${lib}_DEBUG_LIBRARY})
   
-  if(DCMTK_${lib}_LIBRARY)
+  if(DCMTK_${lib}_LIBRARY OR DCMTK_${lib}_DEBUG_LIBRARY)
     list(APPEND DCMTK_LIBRARIES ${lib})
   endif() 
 
   if(NOT DCMTK_${lib}_LIBRARY)
 	message(WARNING "Cannot find library DCMTK_${lib}_LIBRARY")
   endif()
 
   if(NOT DCMTK_${lib}_DEBUG_LIBRARY)
 	message(WARNING "Cannot find library DCMTK_${lib}_DEBUG_LIBRARY")
   endif()
 
  endforeach()
 
 
 set(DCMTK_config_TEST_HEADER osconfig.h)
 set(DCMTK_dcmdata_TEST_HEADER dctypes.h)
 set(DCMTK_dcmimage_TEST_HEADER dicoimg.h)
 set(DCMTK_dcmimgle_TEST_HEADER dcmimage.h)
 set(DCMTK_dcmjpeg_TEST_HEADER djdecode.h)
 set(DCMTK_dcmnet_TEST_HEADER assoc.h)
 set(DCMTK_dcmpstat_TEST_HEADER dcmpstat.h)
 set(DCMTK_dcmqrdb_TEST_HEADER dcmqrdba.h)
 set(DCMTK_dcmrt_TEST_HEADER drmdose.h)
 set(DCMTK_dcmsign_TEST_HEADER sicert.h)
 set(DCMTK_dcmsr_TEST_HEADER dsrtree.h)
 set(DCMTK_dcmtls_TEST_HEADER tlslayer.h)
 set(DCMTK_ofstd_TEST_HEADER ofstdinc.h)
 set(DCMTK_oflog_TEST_HEADER oflog.h)
 
 foreach(dir
     config
     dcmdata
     dcmimage
     dcmimgle
     dcmjpeg
     dcmnet
     dcmpstat
     dcmqrdb
 	dcmrt
     dcmsign
     dcmsr
     dcmtls
     ofstd
 	oflog)
   find_path(DCMTK_${dir}_INCLUDE_DIR
     ${DCMTK_${dir}_TEST_HEADER}
     PATHS
     ${DCMTK_DIR}/${dir}/include
     ${DCMTK_DIR}/${dir}
     ${DCMTK_DIR}/include/${dir}
     ${DCMTK_DIR}/include/dcmtk/${dir}
     ${DCMTK_DIR}/${dir}/include/dcmtk/${dir}
     ${DCMTK_SOURCE_DIR}/${dir}/include
     ${DCMTK_SOURCE_DIR}/${dir}
+    ${DCMTK_SOURCE_DIR}/dcmtk/${dir}
     ${DCMTK_SOURCE_DIR}/include/${dir}
     ${DCMTK_SOURCE_DIR}/include/dcmtk/${dir}
     ${DCMTK_SOURCE_DIR}/${dir}/include/dcmtk/${dir}
     )
   mark_as_advanced(DCMTK_${dir}_INCLUDE_DIR)
 
   if(DCMTK_${dir}_INCLUDE_DIR)
     list(APPEND
       DCMTK_INCLUDE_DIRS
       ${DCMTK_${dir}_INCLUDE_DIR} ${DCMTK_SOURCE_DIR}/${dir}/include ${DCMTK_DIR}/${dir}/include)
   endif()
 endforeach()
 
 if(WIN32)
   list(APPEND DCMTK_LIBRARIES netapi32 wsock32 ws2_32)
 endif()
 
 if(UNIX)
   list(APPEND DCMTK_LIBRARIES pthread)
 endif()
 
 
 if(DCMTK_ofstd_INCLUDE_DIR)
   get_filename_component(DCMTK_dcmtk_INCLUDE_DIR
     ${DCMTK_ofstd_INCLUDE_DIR}
     PATH
     CACHE)
   list(APPEND DCMTK_INCLUDE_DIRS ${DCMTK_dcmtk_INCLUDE_DIR})
   mark_as_advanced(DCMTK_dcmtk_INCLUDE_DIR)
 endif()
 
 endif()
 
 #-----------------------------------------------------------------------------
 # RTTB part to use the found DCMTK
 #   
 IF(NOT DCMTK_FOUND)
   MESSAGE(SEND_ERROR "DCMTK development files not found.\n Please check variables (e.g. DCMTK_DIR) for include directories and libraries.\nYou may set environment variable DCMTK_DIR before pressing 'configure'")
 ENDIF(NOT DCMTK_FOUND)
 
 IF( NOT WIN32 )
   SET(MISSING_LIBS_REQUIRED_BY_DCMTK wrap tiff)
 ENDIF( NOT WIN32 )
 
 LIST(APPEND ALL_INCLUDE_DIRECTORIES ${DCMTK_INCLUDE_DIRS} ${DCMTK_DIR}/include)
+IF(DEFINED RTTB_USE_MITK_DCMTK)
+  LIST(APPEND ALL_INCLUDE_DIRECTORIES ${DCMTK_SOURCE_DIR})
+ENDIF(DEFINED RTTB_USE_MITK_DCMTK)
+
 LIST(APPEND ALL_LIBRARIES ${DCMTK_LIBRARIES} ${MISSING_LIBS_REQUIRED_BY_DCMTK})
diff --git a/cmake/PackageDepends/RTTB_ITK_Config.cmake b/cmake/PackageDepends/RTTB_ITK_Config.cmake
index 527ce0e..31cb3d6 100644
--- a/cmake/PackageDepends/RTTB_ITK_Config.cmake
+++ b/cmake/PackageDepends/RTTB_ITK_Config.cmake
@@ -1,18 +1,29 @@
 #-----------------------------------------------------------------------------
 # Find ITK.
 #-----------------------------------------------------------------------------
 
 FIND_PACKAGE(ITK 4.4 REQUIRED)
 IF(ITK_FOUND)
   INCLUDE(${ITK_USE_FILE})
 ELSE(ITK_FOUND)
   MESSAGE(FATAL_ERROR
           "Cannot build without ITK.  Please set ITK_DIR.")
 ENDIF(ITK_FOUND)
 
 LIST(APPEND ALL_INCLUDE_DIRECTORIES ${ITK_INCLUDE_DIRS})
 LIST(APPEND ALL_LIBRARIES ${ITK_LIBRARIES})
 
 LINK_DIRECTORIES(${ITK_LIBRARY_DIRS})
 
+OPTION(RTTB_USE_SYSTEM_GDCM "Activate checker to choose a GDCM installation that should be linked with ITK. (This is needed e.g. when building against an ITK that is distributed with MITK. MITK uses its own GDCM and not the one distributed with ITK.)" OFF)     
+
+IF (RTTB_USE_SYSTEM_GDCM)
+  MESSAGE (STATUS "RTTB uses system GDCM instead of ITK distribution.")
+  FIND_PACKAGE(GDCM PATHS ${ITK_GDCM_DIR} ${GDCM_DIR} REQUIRED)
+  INCLUDE(${GDCM_USE_FILE})
+  LIST(APPEND ALL_INCLUDE_DIRECTORIES ${GDCM_INCLUDE_DIRS})
+  LIST(APPEND ALL_LIBRARIES ${GDCM_LIBRARIES})	    
+ENDIF (RTTB_USE_SYSTEM_GDCM)
+
+
 CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/ITKConfig.cmake.in ${RTTB_MODULES_CONF_DIR}/ITKConfig.cmake @ONLY)
diff --git a/demoapps/BioModelCalc/CMakeLists.txt b/demoapps/BioModelCalc/CMakeLists.txt
index a649b8d..9e24a9c 100644
--- a/demoapps/BioModelCalc/CMakeLists.txt
+++ b/demoapps/BioModelCalc/CMakeLists.txt
@@ -1,7 +1,8 @@
 MESSAGE (STATUS "generating demo app: BioModelCalc - calculating the radiobiological effect based on dose")
 
+SET(RTTB_Boost_ADDITIONAL_COMPONENT program_options)
 RTTB_CREATE_APPLICATION(BioModelCalc DEPENDS RTTBCore RTTBITKIO RTTBVirtuosIO RTTBDicomIO RTTBHelaxIO RTTBModels PACKAGE_DEPENDS ArgumentParsingLib BoostBinaries)
 IF (NOT WIN32)
 	#CMake 3.1 provides target_compile_features(RTTB_Interpolation cxx_auto_type cxx_nullptr cxx_override) to 			automatically add required compiler flags
 	set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive")
 ENDIF()
diff --git a/demoapps/DoseTool/CMakeLists.txt b/demoapps/DoseTool/CMakeLists.txt
index f7da8ce..dc338ef 100644
--- a/demoapps/DoseTool/CMakeLists.txt
+++ b/demoapps/DoseTool/CMakeLists.txt
@@ -1,7 +1,7 @@
 MESSAGE (STATUS "generating demo app: DoseTool - calculating dose statistics of a structure")
-
+SET(RTTB_Boost_ADDITIONAL_COMPONENT program_options)
 RTTB_CREATE_APPLICATION(DoseTool DEPENDS RTTBCore RTTBITKIO RTTBVirtuosIO RTTBDicomIO RTTBHelaxIO RTTBMasks RTTBMasks RTTBBoostMask RTTBOtherIO RTTBAlgorithms PACKAGE_DEPENDS ArgumentParsingLib BoostBinaries)
 IF (NOT WIN32)
 	#CMake 3.1 provides target_compile_features(RTTB_Interpolation cxx_auto_type cxx_nullptr cxx_override) to 			automatically add required compiler flags
 	set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive")
 ENDIF()
diff --git a/demoapps/VoxelizerTool/CMakeLists.txt b/demoapps/VoxelizerTool/CMakeLists.txt
index 9d39a2d..3e36bb5 100644
--- a/demoapps/VoxelizerTool/CMakeLists.txt
+++ b/demoapps/VoxelizerTool/CMakeLists.txt
@@ -1,7 +1,7 @@
 MESSAGE (STATUS "generating demo app: VoxelizerTool - writing files of voxelized structures")
-
+SET(RTTB_Boost_ADDITIONAL_COMPONENT program_options)
 RTTB_CREATE_APPLICATION(VoxelizerTool DEPENDS RTTBITKIO RTTBOTBMask RTTBBoostMask RTTBDicomIO RTTBMasks RTTBCore PACKAGE_DEPENDS ITK BoostBinaries)
 IF (NOT WIN32)
 	#CMake 3.1 provides target_compile_features(RTTB_Interpolation cxx_auto_type cxx_nullptr cxx_override) to 			automatically add required compiler flags
 	set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive")
 ENDIF()