diff --git a/CMakeLists.txt b/CMakeLists.txt
index f792e08..1d5b64d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,310 +1,318 @@
 #-----------------------------------------------------------------------------
 # This is the root RTToolbox CMakeList file.
 #-----------------------------------------------------------------------------
 PROJECT(RTToolbox)
 
 CMAKE_MINIMUM_REQUIRED(VERSION 3.1)
 
 # RTToolbox version number.
 SET(RTToolbox_VERSION_MAJOR "5")
 SET(RTToolbox_VERSION_MINOR "1")
 SET(RTToolbox_VERSION_PATCH "0")
 
 # 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}")
 SET(RTToolbox_PREFIX "RTTB")
 
 # default build type
 SET(CMAKE_BUILD_TYPE Release)
 
 MARK_AS_ADVANCED(BUILD_SHARED_LIBS)
 
 IF (WIN32)
 	IF (MSVC_VERSION LESS 1800)
 		MESSAGE(FATAL_ERROR "RTToolbox requires at least Visual Studio 2013.")
 	ELSEIF (MSVC_VERSION GREATER_EQUAL 1910)
 		IF (${CMAKE_VERSION} VERSION_LESS "3.10.3")
 			MESSAGE(AUTHOR_WARNING "Please use CMake version 3.10.3 or newer for Visual Studio 2017 as new boost versions are not recognized using old CMake versions.")
 		ENDIF()
 	ENDIF()
 	add_definitions(-D_SCL_SECURE_NO_WARNINGS)
 ELSE (WIN32)
 	IF (CMAKE_COMPILER_IS_GNUCC)
 		IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.3)
 			MESSAGE(AUTHOR_WARNING "RTToolbox was tested with GCC 5 and GCC 7 only. You are using GCC " ${CMAKE_CXX_COMPILER_VERSION} ". You might need to change some code in order to compile RT Toolbox.")
 		ENDIF()
 	ELSE()
 		MESSAGE(AUTHOR_WARNING "RTToolbox was only tested with GCC. This compiler might not work.")	
 	ENDIF()
 ENDIF(WIN32)
 
 #-----------------------------------------------------------------------------
 # 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/rttbFunctionCreateModule.cmake)
+include(cmake/rttbFunctionCheckModuleDependencies.cmake)
+include(cmake/rttbFunctionUseModules.cmake)
 include(cmake/rttbFunctionOrganizeSources.cmake)
+include(cmake/rttbMacroCreateTestModule.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.
 #-----------------------------------------------------------------------------
 #build no tests as default
 OPTION(BUILD_TESTING "build tests" OFF)
 
 IF(BUILD_TESTING)
 SET(CTEST_NEW_FORMAT 1)
 INCLUDE(CTest)
 ENABLE_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
 #-----------------------------------------------------------------------------
 
 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 (NOT RTTB_CXX_STANDARD)
  set(RTTB_CXX_STANDARD 11)
 ENDIF (NOT RTTB_CXX_STANDARD)
 
 set(CMAKE_CXX_STANDARD ${RTTB_CXX_STANDARD} CACHE STRING "")
 set(CMAKE_CXX_STANDARD_REQUIRED 1)
 OPTION(CMAKE_CXX_EXTENSIONS "" ON)
 MARK_AS_ADVANCED(CMAKE_CXX_STANDARD CMAKE_CXX_STANDARD_REQUIRED CMAKE_CXX_EXTENSIONS)
 
 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(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(NOT BUILD_SHARED_LIBS)
 
 SET(RTTB_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
 
 #Raise warning level (MSVC has W3 default warning level)
 IF (WIN32)
 	IF(NOT BUILD_SHARED_LIBS)
 		set(CMAKE_CXX_FLAGS "/W4 /EHsc")
 	ENDIF()
 ELSE()
 	IF (CMAKE_COMPILER_IS_GNUCC)
 		set(CMAKE_CXX_FLAGS "-Wall")
 	ENDIF()
 ENDIF()
 
 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.
 #-----------------------------------------------------------------------------
 
 OPTION(BUILD_All_Modules "All modules will be built" OFF)
 
 OPTION(BUILD_Apps "Determine if the CLI applications will be generated." OFF)
 MESSAGE (STATUS "generating Project RTToolbox")
 ADD_SUBDIRECTORY (code)
 IF (BUILD_Apps)
 	ADD_SUBDIRECTORY (apps)
 ENDIF()
 
 IF (BUILD_All_Modules OR BUILD_IO_ITK)
 	OPTION(RTTB_ITK5_SUPPORT "Determine if ITK v5 should be supported." OFF)
 ENDIF()
 
 IF (BUILD_TESTING)
   ADD_SUBDIRECTORY (testing)
 ENDIF (BUILD_TESTING)
 
 ADD_SUBDIRECTORY (documentation)
 
 #-----------------------------------------------------------------------------
 # Help other projects use RTToolbox.
 #-----------------------------------------------------------------------------
 
 EXPORT(PACKAGE RTToolbox)
 
+# ---------------- Export targets -----------------
+SET(RTToolbox_TARGETS_FILE "${RTToolbox_BINARY_DIR}/RTToolboxTargets.cmake")
+FILE(WRITE ${RTToolbox_TARGETS_FILE} "# Generated by CMake, do not edit!")
+
+set(targets_to_export)
+get_property(module_targets GLOBAL PROPERTY RTTB_MODULE_TARGETS)
+if(module_targets)
+  list(APPEND targets_to_export ${module_targets})
+endif()
+
+export(TARGETS ${targets_to_export} APPEND
+       FILE ${RTToolbox_TARGETS_FILE})
+
 # 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
 		DESTINATION ${RTTOOLBOX_INSTALL_PACKAGE_DIR}
 		COMPONENT Development
     )
 ENDIF(NOT RTToolbox_INSTALL_NO_DEVELOPMENT)
diff --git a/cmake/MacroParseArguments.cmake b/cmake/MacroParseArguments.cmake
deleted file mode 100644
index c7cfc53..0000000
--- a/cmake/MacroParseArguments.cmake
+++ /dev/null
@@ -1,79 +0,0 @@
-# MACRO (MACRO_PARSE_ARGUMENTS prefix arg_names option_names)
-#
-#   From http://www.cmake.org/Wiki/CMakeMacroParseArguments:
-#
-#   The MACRO_PARSE_ARGUMENTS macro will take the arguments of another macro and
-#   define several variables:
-#
-#     1) The first argument to is a prefix to put on all variables it creates.
-#     2) The second argument is a quoted list of names,
-#     3) and the third argument is a quoted list of options.
-#
-#   The rest of MACRO_PARSE_ARGUMENTS are arguments from another macro to be
-#   parsed.
-#
-#   MACRO_PARSE_ARGUMENTS(prefix arg_names options arg1 arg2...)
-#
-#   For each item in options, MACRO_PARSE_ARGUMENTS will create a variable
-#   with that name, prefixed with prefix_. So, for example, if prefix is
-#   MY_MACRO and options is OPTION1;OPTION2, then PARSE_ARGUMENTS will create
-#   the variables MY_MACRO_OPTION1 and MY_MACRO_OPTION2. These variables will
-#   be set to true if the option exists in the command line or false otherwise.
-#
-#   For each item in arg_names, MACRO_PARSE_ARGUMENTS will create a variable
-#   with that name, prefixed with prefix_. Each variable will be filled with the
-#   arguments that occur after the given arg_name is encountered up to the next
-#   arg_name or the end of the arguments. All options are removed from these
-#   lists.
-#
-#   MACRO_PARSE_ARGUMENTS also creates a prefix_DEFAULT_ARGS variable containing
-#   the list of all arguments up to the first arg_name encountered.
-
-IF(NOT COMMAND MACRO_PARSE_ARGUMENTS)
-
-MACRO (MACRO_PARSE_ARGUMENTS prefix arg_names option_names)
-
-   SET(DEFAULT_ARGS)
-
-   FOREACH (arg_name ${arg_names})
-      SET(${prefix}_${arg_name})
-   ENDFOREACH (arg_name)
-
-   FOREACH (option ${option_names})
-      SET(${prefix}_${option} FALSE)
-   ENDFOREACH (option)
-
-   SET(current_arg_name DEFAULT_ARGS)
-   SET(current_arg_list)
-
-   FOREACH (arg ${ARGN})
-
-      SET(larg_names ${arg_names})
-      LIST(FIND larg_names "${arg}" is_arg_name)
-
-      IF (is_arg_name GREATER -1)
-
-         SET(${prefix}_${current_arg_name} ${current_arg_list})
-         SET(current_arg_name "${arg}")
-         SET(current_arg_list)
-
-      ELSE (is_arg_name GREATER -1)
-
-         SET(loption_names ${option_names})
-         LIST(FIND loption_names "${arg}" is_option)
-
-         IF (is_option GREATER -1)
-            SET(${prefix}_${arg} TRUE)
-         ELSE (is_option GREATER -1)
-            SET(current_arg_list ${current_arg_list} "${arg}")
-         ENDIF (is_option GREATER -1)
-
-      ENDIF (is_arg_name GREATER -1)
-
-   ENDFOREACH (arg ${ARGN})
-
-   SET(${prefix}_${current_arg_name} ${current_arg_list})
-
-ENDMACRO (MACRO_PARSE_ARGUMENTS)
-
-ENDIF(NOT COMMAND MACRO_PARSE_ARGUMENTS)
diff --git a/cmake/PackageDepends/RTTB_Boost_Config.cmake b/cmake/PackageDepends/RTTB_Boost_Config.cmake
index 3670d99..2dc217d 100644
--- a/cmake/PackageDepends/RTTB_Boost_Config.cmake
+++ b/cmake/PackageDepends/RTTB_Boost_Config.cmake
@@ -1,5 +1,29 @@
-  SET(BOOST_MIN_VERSION "1.64.0")
-  FIND_PACKAGE(Boost ${BOOST_MIN_VERSION} REQUIRED QUIET)
+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)
 
-  LIST(APPEND ALL_INCLUDE_DIRECTORIES ${Boost_INCLUDE_DIRS})
+IF(BUILD_SHARED_LIBS OR RTTB_USE_MITK_BOOST)
+  SET(Boost_USE_STATIC_LIBS OFF)
+  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 OR RTTB_USE_MITK_BOOST)
 
+SET(BOOST_MIN_VERSION "1.64.0")
+
+SET(RTTB_Boost_REQUIRED_COMPONENTS_BY_MODULE ${Boost_REQUIRED_COMPONENTS_BY_MODULE} ${RTTB_Boost_ADDITIONAL_COMPONENT})
+
+FIND_PACKAGE(Boost ${BOOST_MIN_VERSION} REQUIRED COMPONENTS ${RTTB_Boost_REQUIRED_COMPONENTS_BY_MODULE} QUIET)
+
+if(Boost_REQUIRED_COMPONENTS_BY_MODULE)
+  foreach(boost_component ${Boost_REQUIRED_COMPONENTS_BY_MODULE})
+    list(APPEND ALL_LIBRARIES "Boost::${boost_component}")
+  endforeach()
+endif()
+
+IF(BUILD_SHARED_LIBS OR RTTB_USE_MITK_BOOST)
+  IF(MSVC)
+     list(APPEND ALL_LIBRARIES "Boost::dynamic_linking" "bcrypt")
+  ENDIF(MSVC)
+ENDIF(BUILD_SHARED_LIBS OR RTTB_USE_MITK_BOOST)
diff --git a/cmake/moduleExports.h.in b/cmake/moduleExports.h.in
index 0e79d53..ca7df50 100644
--- a/cmake/moduleExports.h.in
+++ b/cmake/moduleExports.h.in
@@ -1,36 +1,36 @@
 // -----------------------------------------------------------------------
 // RTToolbox - DKFZ radiotherapy quantitative evaluation library
 //
 // Copyright (c) German Cancer Research Center (DKFZ),
 // Software development for Integrated Diagnostics and Therapy (SIDT).
 // ALL RIGHTS RESERVED.
 // See rttbCopyright.txt or
 // http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
 //
 // This software is distributed WITHOUT ANY WARRANTY; without even
 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE.  See the above copyright notices for more information.
 //
 //------------------------------------------------------------------------
 
 #include "RTToolboxConfigure.h"
 
 #ifndef @MODULE_NAME@_EXPORTS_H
   #define @MODULE_NAME@_EXPORTS_H
   #if defined(WIN32) && !defined(RTTB_STATIC)
-    #ifdef @MODULE_PROVIDES@_EXPORTS
-	  #define @MODULE_EXPORT_DEFINE@ __declspec(dllexport)
+    #ifdef @MODULE_NAME@_EXPORTS
+      #define @MODULE_EXPORT_DEFINE@ __declspec(dllexport)
     #else
-	  #define @MODULE_EXPORT_DEFINE@ __declspec(dllimport)
+      #define @MODULE_EXPORT_DEFINE@ __declspec(dllimport)
     #endif
   #else
     #define @MODULE_EXPORT_DEFINE@
   #endif
   #ifndef _CMAKE_MODULENAME
-    #ifdef @MODULE_PROVIDES@_EXPORTS
+    #ifdef @MODULE_NAME@_EXPORTS
       #define _CMAKE_MODULENAME "@MODULE_NAME@"
     #endif
   #endif
 #endif
 
 
diff --git a/cmake/rttbFunctionCheckModuleDependencies.cmake b/cmake/rttbFunctionCheckModuleDependencies.cmake
new file mode 100644
index 0000000..fd5108e
--- /dev/null
+++ b/cmake/rttbFunctionCheckModuleDependencies.cmake
@@ -0,0 +1,69 @@
+#! Checks if all required modules and packages exist and stores missing
+#! dependencies in <missing_deps>.
+#!
+#! Usage:
+#!
+#! rttb_check_module_dependencies(
+#!   MODULES <module-list>
+#!   PACKAGES <package-list>
+#!   MISSING_DEPENDENCIES_VAR <missing_deps>
+#!   MODULE_DEPENDENCIES_VAR <module_deps>
+#!   PACKAGE_DEPENDENCIES_VAR <package_deps>)
+#!
+function(rttb_check_module_dependencies)
+
+  set(_macro_params
+      MISSING_DEPENDENCIES_VAR # variable for storing missing dependencies
+      MODULE_DEPENDENCIES_VAR  # variable for storing all module dependencies
+      PACKAGE_DEPENDENCIES_VAR # variable for storing all package dependencies
+     )
+
+  set(_macro_multiparams
+      MODULES                  # MITK modules which the given TARGET uses
+      PACKAGES                 # MITK packages which the given TARGET uses
+     )
+
+  set(_macro_options )
+
+  cmake_parse_arguments(CHECK "" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
+
+  set(missing_deps )
+  set(depends ${CHECK_MODULES})
+  set(package_depends ${CHECK_PACKAGES})
+  set(module_names )
+  set(package_names )
+
+  foreach(dep ${depends})
+    if(NOT dep STREQUAL "PUBLIC" AND NOT dep STREQUAL "PRIVATE" AND NOT dep STREQUAL "INTERFACE")
+      if(NOT TARGET ${dep})
+        list(APPEND missing_deps ${dep})
+      endif()
+      list(APPEND module_names ${dep})
+    endif()
+  endforeach()
+
+  set(package_names)
+  if(package_depends)
+    _rttb_parse_package_args(${package_depends})
+    set(package_names ${PUBLIC_PACKAGE_NAMES} ${PRIVATE_PACKAGE_NAMES} ${INTERFACE_PACKAGE_NAMES})
+    list(REMOVE_DUPLICATES package_names)
+    foreach(_package ${package_names})
+      if((DEFINED MITK_USE_${_package}) AND NOT (${MITK_USE_${_package}}))
+        list(APPEND missing_deps ${_package})
+      endif()
+    endforeach()
+  endif()
+
+  if(missing_deps)
+    list(REMOVE_DUPLICATES missing_deps)
+    if(CHECK_MISSING_DEPENDENCIES_VAR)
+      set(${CHECK_MISSING_DEPENDENCIES_VAR} ${missing_deps} PARENT_SCOPE)
+    endif()
+  endif()
+  if(CHECK_MODULE_DEPENDENCIES_VAR)
+    set(${CHECK_MODULE_DEPENDENCIES_VAR} ${module_names} PARENT_SCOPE)
+  endif()
+  if(CHECK_PACKAGE_DEPENDENCIES_VAR)
+    set(${CHECK_PACKAGE_DEPENDENCIES_VAR} ${package_names} PARENT_SCOPE)
+  endif()
+endfunction()
diff --git a/cmake/rttbFunctionCreateModule.cmake b/cmake/rttbFunctionCreateModule.cmake
new file mode 100644
index 0000000..52d6d9b
--- /dev/null
+++ b/cmake/rttbFunctionCreateModule.cmake
@@ -0,0 +1,250 @@
+##################################################################
+#
+# RTTB_CREATE_MODULE
+#
+#! Creates a module for the automatic module dependency system within RTTB.
+#!
+#! Example:
+#!
+#! \code
+#! RTTB_CREATE_MODULE2( NewModule
+#!     DEPENDS PUBLIC RTTBCore
+#!     PACKAGE_DEPENDS
+#!       PRIVATE Boost|System
+#!       PUBLIC  ITK|IO
+#! \endcode
+#!
+#! A modules source files are specified in a separate CMake file usually
+#! called files.cmake, located in the module root directory. The
+#! RTTB_CREATE_MODULE2() macro evaluates the following CMake variables
+#! from the files.cmake file:
+#!
+#! - CPP_FILES A list of .cpp files
+#! - H_FILES A list of .h files without a corresponding .cpp file
+#! - TXX_FILES A list of .txx files
+#! - DOX_FILES A list of .dox Doxygen files
+#!
+#! List of variables available after the function is called:
+#! - MODULE_NAME
+#! - MODULE_TARGET
+#! - MODULE_IS_ENABLED
+#!
+#! Parameters (mandatory):
+#! \param <moduleName> The module name (also used as target name)
+#!
+#! Parameters (all optional):
+#!
+#! \param DEPRECATED_SINCE Marks this modules as deprecated since <arg>
+#! \param DESCRIPTION A description for this module
+#!
+#! Multi-value Parameters (all optional):
+#!
+#! \param INCLUDE_DIRS Include directories for this module:
+#!        \verbatim
+#! [[PUBLIC|PRIVATE|INTERFACE] <dir1>...]...
+#! \endverbatim
+#!        The default scope for include directories is PUBLIC.
+#! \param DEPENDS List of module dependencies:
+#!        \verbatim
+#! [[PUBLIC|PRIVATE|INTERFACE] <module1>...]...
+#! \endverbatim
+#!        The default scope for module dependencies is PUBLIC.
+#! \param PACKAGE_DEPENDS List of public packages dependencies (e.g. Qt, VTK, etc.).
+#!        Package dependencies have the following syntax:
+#!        \verbatim
+#! [PUBLIC|PRIVATE|INTERFACE] PACKAGE[|COMPONENT1[+COMPONENT2]...]
+#! \endverbatim
+#!        The default scope for package dependencies is PRIVATE.
+#!
+##################################################################
+function(RTTB_CREATE_MODULE)
+
+  set(_macro_params
+      DEPRECATED_SINCE       # marks this modules as deprecated
+      DESCRIPTION            # a description for this module
+     )
+
+  set(_macro_multiparams
+      INCLUDE_DIRS           # include directories: [PUBLIC|PRIVATE|INTERFACE] <list>
+      DEPENDS                # list of modules this module depends on: [PUBLIC|PRIVATE|INTERFACE] <list>
+      PACKAGE_DEPENDS        # list of "packages this module depends on (e.g. Qt, VTK, etc.): [PUBLIC|PRIVATE|INTERFACE] <package-list>
+      TARGET_DEPENDS         # list of CMake targets this module should depend on: [PUBLIC|PRIVATE|INTERFACE] <list>
+     )
+
+  set(_macro_options
+      FORCE_STATIC           # force building this module as a static library
+      HEADERS_ONLY           # this module is a headers-only library
+      C_MODULE               # compile all source files as C sources
+      CXX_MODULE             # compile all source files as C++ sources
+     )
+
+  cmake_parse_arguments(MODULE "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
+
+  set(MODULE_NAME ${MODULE_UNPARSED_ARGUMENTS})
+
+  # -----------------------------------------------------------------
+  # Sanity checks
+
+  if(NOT MODULE_NAME)
+    message(SEND_ERROR "The module name must not be empty")
+  endif()
+
+  set(_Module_type Module)
+
+  set(MODULE_FILES_CMAKE files.cmake)
+
+  # -----------------------------------------------------------------
+  # Check if module should be build
+
+  set(MODULE_TARGET ${MODULE_NAME})
+
+  # assume worst case
+  set(MODULE_IS_ENABLED 0)
+  # first we check if we have an explicit module build list
+  if(RTTB_MODULES_TO_BUILD)
+    list(FIND RTTB_MODULES_TO_BUILD ${MODULE_NAME} _MOD_INDEX)
+    if(_MOD_INDEX EQUAL -1)
+      set(MODULE_IS_EXCLUDED 1)
+    endif()
+  endif()
+
+  if(NOT MODULE_IS_EXCLUDED)
+    message(STATUS "configuring Module ${MODULE_NAME}...") 
+    # first of all we check for the dependencies
+    _rttb_parse_package_args(${MODULE_PACKAGE_DEPENDS})
+    rttb_check_module_dependencies(MODULES ${MODULE_DEPENDS}
+                                   PACKAGES ${PACKAGE_NAMES}
+                                   MISSING_DEPENDENCIES_VAR _MISSING_DEP
+                                   PACKAGE_DEPENDENCIES_VAR PACKAGE_NAMES)
+
+    if(_MISSING_DEP)
+      message("${_Module_type} ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}")
+      set(MODULE_IS_ENABLED 0)
+    else()
+      set(MODULE_IS_ENABLED 1)
+      # now check for every package if it is enabled. This overlaps a bit with
+      # RTTB_CHECK_MODULE ...
+      foreach(_package ${PACKAGE_NAMES})
+        if((DEFINED RTTB_USE_${_package}) AND NOT (RTTB_USE_${_package}))
+          message("${_Module_type} ${MODULE_NAME} won't be built. Turn on RTTB_USE_${_package} if you want to use it.")
+          set(MODULE_IS_ENABLED 0)
+          break()
+        endif()
+      endforeach()
+    endif()
+  endif()
+
+  # -----------------------------------------------------------------
+  # Start creating the module
+
+  if(MODULE_IS_ENABLED)
+
+    # clear variables defined in files.cmake
+    set(CPP_FILES )
+    set(H_FILES )
+    set(TXX_FILES )
+    set(DOX_FILES )
+
+    set(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT)
+
+    if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${MODULE_FILES_CMAKE}")
+      include(${MODULE_FILES_CMAKE})
+    endif()
+
+    if(CPP_FILES)
+      set(MODULE_HEADERS_ONLY 0)
+    else()
+      set(MODULE_HEADERS_ONLY 1)
+    endif()
+
+    if(MODULE_FORCE_STATIC)
+      set(_STATIC ${RTTB_WIN32_FORCE_STATIC)
+    else()
+      set(_STATIC )
+    endif(MODULE_FORCE_STATIC)
+
+    ORGANIZE_SOURCES(
+      SOURCE ${CPP_FILES}
+      HEADER ${H_FILES}
+      TXX ${TXX_FILES}
+      DOC ${DOX_FILES}
+      )
+
+    set(coverage_sources
+        ${CPP_FILES} ${H_FILES} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES})
+
+    # ---------------------------------------------------------------
+    # Create the actual module target
+
+    if(MODULE_HEADERS_ONLY)
+      add_library(${MODULE_TARGET} INTERFACE)
+      # INTERFACE_LIBRARY targets may only have whitelisted properties. The property "FOLDER" is not allowed.
+      # set_property(TARGET ${MODULE_TARGET} PROPERTY FOLDER "${RTTB_ROOT_FOLDER}/Modules")
+    else()
+      add_library(${MODULE_TARGET} ${_STATIC}
+                  ${coverage_sources} ${CPP_FILES_GENERATED}
+                  ${DOX_FILES})
+      set_property(TARGET ${MODULE_TARGET} PROPERTY FOLDER "${RTTB_ROOT_FOLDER}/Modules")
+
+      # add the target name to a global property which is used in the top-level
+      # CMakeLists.txt file to export the target
+      set_property(GLOBAL APPEND PROPERTY RTTB_MODULE_TARGETS ${MODULE_TARGET})
+
+      if(MODULE_DEPRECATED_SINCE)
+        set_property(TARGET ${MODULE_TARGET} PROPERTY RTTB_MODULE_DEPRECATED_SINCE ${MODULE_DEPRECATED_SINCE})
+      endif()
+
+      # create export macros
+      CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/moduleExports.h.in ${RTTB_MODULES_CONF_DIR}/${MODULE_NAME}Exports.h @ONLY)
+
+      # create export macros
+#      generate_export_header(${MODULE_NAME}
+#          EXPORT_FILE_NAME ${MODULE_NAME}Exports.h)
+
+      target_include_directories(${MODULE_TARGET} PUBLIC ${CMAKE_CURRENT_BINARY_DIR} ${RTTB_MODULES_CONF_DIR})
+
+    endif()
+
+    # ---------------------------------------------------------------
+    # Properties for both header-only and compiled modules
+
+    if(MODULE_HEADERS_ONLY)
+      set(_module_property_type INTERFACE)
+    else()
+      set(_module_property_type PUBLIC)
+    endif()
+
+    if(MODULE_TARGET_DEPENDS)
+      target_link_libraries(${MODULE_TARGET} ${MODULE_TARGET_DEPENDS})
+    endif()
+
+    set(DEPENDS "${MODULE_DEPENDS}")
+    if(DEPENDS OR MODULE_PACKAGE_DEPENDS)
+      rttb_use_modules(TARGET ${MODULE_TARGET}
+                       MODULES ${DEPENDS}
+                       PACKAGES ${MODULE_PACKAGE_DEPENDS}
+                      )
+    endif()
+
+    # add include directories
+    target_include_directories(${MODULE_TARGET} ${_module_property_type} .)
+    target_include_directories(${MODULE_TARGET} ${_module_property_type} ${MODULE_INCLUDE_DIRS})
+
+  endif()
+
+  # -----------------------------------------------------------------
+  # Record missing dependency information
+
+  if(_MISSING_DEP)
+    if(MODULE_DESCRIPTION)
+      set(MODULE_DESCRIPTION "${MODULE_DESCRIPTION} (missing dependencies: ${_MISSING_DEP})")
+    else()
+      set(MODULE_DESCRIPTION "(missing dependencies: ${_MISSING_DEP})")
+    endif()
+  endif()
+
+  set(MODULE_NAME ${MODULE_NAME} PARENT_SCOPE)
+  set(MODULE_TARGET ${MODULE_TARGET} PARENT_SCOPE)
+  set(MODULE_IS_ENABLED ${MODULE_IS_ENABLED} PARENT_SCOPE)
+
+endfunction()
diff --git a/cmake/rttbFunctionOrganizeSources.cmake b/cmake/rttbFunctionOrganizeSources.cmake
index c60ecda..c6e96f2 100644
--- a/cmake/rttbFunctionOrganizeSources.cmake
+++ b/cmake/rttbFunctionOrganizeSources.cmake
@@ -1,51 +1,53 @@
 FUNCTION(ORGANIZE_SOURCES)
 
   # this functions gets a filelist as input and looks
   # for corresponding h-files to add them to the project.
   
   # additionally files are grouped in source-groups.
   
   # No parameters explicitly declared here, because
   # we want to allow for variable argument lists, which
   # are later access by the keyword FOREACH(MYFILE ${ARGV})
   
   # output: after calling the macro, files that were found
   # correspondigly to the given files are stored in the
   # variable:
   # ${CORRESPONDING_H_FILES}
   # ${CORRESPONDING_TXX_FILES}
   
   # Globbed can be found in the variables
   # ${GLOBBED_TXX_FILES} (CURRENTLY COMMENTED OUT)
   # ${GLOBBED_DOX_FILES}
 
-  MACRO_PARSE_ARGUMENTS(_ORG "HEADER;SOURCE;TXX;DOC" "" ${ARGN})
+  cmake_parse_arguments(_ORG "" "" "HEADER;SOURCE;TXX;DOC" ${ARGN})
 
   SET(CORRESPONDING__H_FILES "" )
   SET(GLOBBED__H_FILES "" )
 
   IF(_ORG_HEADER)
     FOREACH(_file ${_ORG_SOURCE})
       STRING(REGEX REPLACE "(.*)\\.(txx|tpp|cpp|c|cxx)$" "\\1.h" H_FILE ${_file})
       IF(EXISTS ${H_FILE})
         LIST(APPEND CORRESPONDING__H_FILES "${H_FILE}")
       ENDIF()
     ENDFOREACH()
   ELSE()
     FILE(GLOB_RECURSE GLOBBED__H_FILES *.h)
   ENDIF()
-  
-  
+
+  set(CORRESPONDING__H_FILES ${CORRESPONDING__H_FILES} PARENT_SCOPE)
+  set(GLOBBED__H_FILES ${GLOBBED__H_FILES} PARENT_SCOPE)
+
   #_MACRO_APPEND_TO_LIST(_ORG_SOURCE "${CMAKE_CURRENT_SOURCE_DIR}/")
   SOURCE_GROUP("Source Files" FILES ${_ORG_SOURCE})
   
   #_MACRO_APPEND_TO_LIST(_ORG_TXX "${CMAKE_CURRENT_SOURCE_DIR}/")
   SOURCE_GROUP("Template Files" FILES ${_ORG_TXX})
  
   #_MACRO_APPEND_TO_LIST(_ORG_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/")
   SOURCE_GROUP("Header Files" FILES ${_ORG_HEADER} ${CORRESPONDING__H_FILES} ${GLOBBED__H_FILES})
    
   #_MACRO_APPEND_TO_LIST(_ORG_DOC "${CMAKE_CURRENT_SOURCE_DIR}/")
   SOURCE_GROUP("Doxygen Files" FILES ${_ORG_DOC})
     
 ENDFUNCTION(ORGANIZE_SOURCES)
diff --git a/cmake/rttbFunctionUseModules.cmake b/cmake/rttbFunctionUseModules.cmake
new file mode 100644
index 0000000..e286195
--- /dev/null
+++ b/cmake/rttbFunctionUseModules.cmake
@@ -0,0 +1,169 @@
+function(_rttb_parse_package_args)
+  set(package_list ${ARGN})
+
+  set(PUBLIC_PACKAGE_NAMES )
+  set(PRIVATE_PACKAGE_NAMES )
+  set(INTERFACE_PACKAGE_NAMES )
+
+  set(_package_visibility PRIVATE)
+  foreach(_package ${package_list})
+    if(_package STREQUAL "PUBLIC" OR _package STREQUAL "PRIVATE" OR _package STREQUAL "INTERFACE")
+      set(_package_visibility ${_package})
+    else()
+      list(APPEND packages ${_package})
+      set(_package_name )
+      set(_package_components_list )
+      string(REPLACE "|" ";" _package_list ${_package})
+      if("${_package_list}" STREQUAL "${_package}")
+        set(_package_name ${_package})
+      else()
+        list(GET _package_list 0 _package_name)
+        list(GET _package_list 1 _package_components)
+        string(REPLACE "+" ";" _package_components_list "${_package_components}")
+        if(NOT _package_name OR NOT _package_components)
+          message(SEND_ERROR "PACKAGE argument syntax wrong. ${_package} is not of the form PACKAGE[|COMPONENT1[+COMPONENT2]...]")
+        endif()
+      endif()
+      list(APPEND ${_package_visibility}_PACKAGE_NAMES ${_package_name})
+      list(APPEND ${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS ${_package_components_list})
+    endif()
+  endforeach()
+
+  # remove duplicates and set package components in parent scope
+  foreach(_package_visibility PUBLIC PRIVATE INTERFACE)
+    foreach(_package_name ${${_package_visibility}_PACKAGE_NAMES})
+      if(${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS)
+        list(REMOVE_DUPLICATES ${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS)
+      endif()
+      set(${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS ${${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS} PARENT_SCOPE)
+    endforeach()
+  endforeach()
+
+  set(PUBLIC_PACKAGE_NAMES ${PUBLIC_PACKAGE_NAMES} PARENT_SCOPE)
+  set(PRIVATE_PACKAGE_NAMES ${PRIVATE_PACKAGE_NAMES} PARENT_SCOPE)
+  set(INTERFACE_PACKAGE_NAMES ${INTERFACE_PACKAGE_NAMES} PARENT_SCOPE)
+  set(PACKAGE_NAMES ${PUBLIC_PACKAGE_NAMES} ${PRIVATE_PACKAGE_NAMES} ${INTERFACE_PACKAGE_NAMES} PARENT_SCOPE)
+endfunction()
+
+function(_include_package_config pkg_config_file)
+  # wrap the inclusion of the RTTB_<pkg>_Config.cmake file in a
+  # function to create a scope for its variables; this allows
+  # multiple inclusions of the file in the parent scope
+  include(${pkg_config_file})
+  set(ALL_INCLUDE_DIRECTORIES ${ALL_INCLUDE_DIRECTORIES} PARENT_SCOPE)
+  set(ALL_LINK_DIRECTORIES ${ALL_LINK_DIRECTORIES} PARENT_SCOPE)
+  set(ALL_LIBRARIES ${ALL_LIBRARIES} PARENT_SCOPE)
+  set(ALL_COMPILE_DEFINITIONS ${ALL_COMPILE_DEFINITIONS} PARENT_SCOPE)
+  set(ALL_COMPILE_OPTIONS ${ALL_COMPILE_OPTIONS} PARENT_SCOPE)
+endfunction()
+
+#! This CMake function sets up the necessary include directories,
+#! linker dependencies, and compile flags for a given target which
+#! depends on a set of RTTB modules or packages.
+#!
+#! A package argument is of the form
+#!
+#!   [PUBLIC|PRIVATE|INTERFACE] PACKAGE[|COMPONENT1[+COMPONENT2]...]
+#!
+#! where PACKAGE is the package name (e.g. VTK) and components are
+#! the names of required package components or libraries.
+#!
+#! If a dependency is not available, an error is thrown.
+function(rttb_use_modules)
+
+  set(_macro_params
+      TARGET           # The target name (required)
+     )
+
+  set(_macro_multiparams
+      MODULES          # MITK modules which the given TARGET uses
+      PACKAGES         # MITK packages which the given TARGET uses
+     )
+
+  set(_macro_options )
+
+  cmake_parse_arguments(USE "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
+
+  # Sanity checks
+  if(NOT USE_TARGET)
+    message(SEND_ERROR "Required TARGET argument missing.")
+  elseif(NOT TARGET ${USE_TARGET})
+    message(SEND_ERROR "The given TARGET argument ${USE_TARGET} is not a valid target")
+  endif()
+
+  set(depends ${USE_MODULES})
+  set(package_depends ${USE_PACKAGES})
+
+  if(depends)
+    # Iterate over all module dependencies
+    foreach(dependency ${depends})
+      if(TARGET ${dependency} AND NOT MODULE_IS_DEPRECATED)
+        get_target_property(_is_interface_lib ${dependency} TYPE)
+        if(NOT _is_interface_lib)
+          get_target_property(_dependency_deprecated_since ${dependency} RTTB_MODULE_DEPRECATED_SINCE)
+          if(_dependency_deprecated_since)
+            message(WARNING "Module ${dependency} is deprecated since ${_dependency_deprecated_since}")
+          endif()
+        endif()
+      endif()
+    endforeach()
+    target_link_libraries(${USE_TARGET} PUBLIC ${depends})
+  endif()
+
+  # Parse package dependencies
+  if(package_depends)
+    _rttb_parse_package_args(${package_depends})
+
+    # Some package config files rely on a
+    # properly set "MODULE_NAME" variable for the current target.
+    set(MODULE_NAME ${USE_TARGET})
+    # Read all package information
+    foreach(_package_visibility INTERFACE PUBLIC PRIVATE)
+      foreach(_package ${${_package_visibility}_PACKAGE_NAMES})
+        set(ALL_INCLUDE_DIRECTORIES)
+        set(ALL_LINK_DIRECTORIES)
+        set(ALL_LIBRARIES)
+        set(ALL_COMPILE_DEFINITIONS)
+        set(ALL_COMPILE_OPTIONS)
+
+        set(${_package}_REQUIRED_COMPONENTS_BY_MODULE ${${_package_visibility}_${_package}_REQUIRED_COMPONENTS})
+        set(_package_found 0)
+        foreach(dir ${MODULES_PACKAGE_DEPENDS_DIRS})
+          if((NOT DEFINED RTTB_USE_${_package} OR RTTB_USE_${_package}) AND EXISTS "${dir}/RTTB_${_package}_Config.cmake")
+            _include_package_config("${dir}/RTTB_${_package}_Config.cmake")
+            set(_package_found 1)
+            break()
+          endif()
+        endforeach()
+        if(_package_found)
+          if(ALL_INCLUDE_DIRECTORIES)
+            list(REMOVE_DUPLICATES ALL_INCLUDE_DIRECTORIES)
+            target_include_directories(${USE_TARGET} SYSTEM ${_package_visibility} ${ALL_INCLUDE_DIRECTORIES})
+          endif()
+          if(ALL_LINK_DIRECTORIES)
+            list(REMOVE_DUPLICATES ALL_LINK_DIRECTORIES)
+            target_link_directories(${USE_TARGET} ${_package_visibility} ${ALL_LINK_DIRECTORIES})
+          endif()
+          if(ALL_LIBRARIES)
+            # Don't remove "duplicats" because ALL_LIBRARIES may be of the form:
+            # "general;bla;debug;blad;general;foo;debug;food"
+            target_link_libraries(${USE_TARGET} ${_package_visibility} ${ALL_LIBRARIES})
+          endif()
+          if(ALL_COMPILE_DEFINITIONS)
+            list(REMOVE_DUPLICATES ALL_COMPILE_DEFINITIONS)
+            # Compile definitions are always added "PRIVATE" to avoid multiple definitions
+            # on the command line due to transitive and direct dependencies adding the
+            # same definitions.
+            target_compile_definitions(${USE_TARGET} PRIVATE ${ALL_COMPILE_DEFINITIONS})
+          endif()
+          if(ALL_COMPILE_OPTIONS)
+            list(REMOVE_DUPLICATES ALL_COMPILE_OPTIONS)
+            target_compile_options(${USE_TARGET} ${_package_visibility} ${ALL_COMPILE_OPTIONS})
+          endif()
+        else()
+          message(SEND_ERROR "Missing package: ${_package}")
+        endif()
+      endforeach()
+    endforeach()
+  endif()
+endfunction()
diff --git a/cmake/rttbMacroCheckModule.cmake b/cmake/rttbMacroCheckModule.cmake
deleted file mode 100644
index 5b47e3d..0000000
--- a/cmake/rttbMacroCheckModule.cmake
+++ /dev/null
@@ -1,73 +0,0 @@
-# Usage: RTTB_CHECK_MODULE(RESULT_VAR [dependencies ...] )
-# check if all required modules exist and stores missing module names in RESULT_VAR.
-MACRO(RTTB_CHECK_MODULE RESULT_VAR)
-  SET(${RESULT_VAR} "")
-  SET(DEPENDS "")
-  SET(DEPENDS_BEFORE "not initialized")
-  SET(PACKAGE_DEPENDS "")
-  
-  
-  # check for each parameter if it is a package (3rd party)
-  FOREACH(package ${ARGN})
-    SET(is_package)
-    FOREACH(dir ${MODULES_PACKAGE_DEPENDS_DIRS})
-      IF(EXISTS "${dir}/RTTB_${package}_Config.cmake") 
-        LIST(APPEND PACKAGE_DEPENDS ${package})
-        SET(is_package 1)
-        BREAK()
-      ENDIF()
-    ENDFOREACH()
-    IF(NOT is_package)
-      LIST(APPEND DEPENDS ${package}) 
-    ENDIF()
-  ENDFOREACH(package)
-
-  # create a list of all lowercase module names
-  FILE(GLOB _ALL_MODULES RELATIVE ${RTTB_MODULES_CONF_DIR} ${RTTB_MODULES_CONF_DIR}/*Config.cmake)
-  SET(_ALL_MODULES_LOWERCASE "")
-  FOREACH(_module ${_ALL_MODULES})
-    STRING(TOLOWER ${_module} _lowermodule)
-    LIST(APPEND _ALL_MODULES_LOWERCASE ${_lowermodule})
-  ENDFOREACH(_module ${_ALL_MODULES})
-
-  WHILE(NOT "${DEPENDS}" STREQUAL "${DEPENDS_BEFORE}")
-    SET(DEPENDS_BEFORE ${DEPENDS})
-    FOREACH(dependency ${DEPENDS})
-      
-      SET(_dependency_file_name ${dependency}Config.cmake)
-      LIST(FIND _ALL_MODULES ${_dependency_file_name} _index)
-      IF(NOT _index EQUAL -1)
-        INCLUDE(${RTTB_MODULES_CONF_DIR}/${dependency}Config.cmake)
-        IF(${dependency}_IS_ENABLED)
-          LIST(APPEND DEPENDS ${${dependency}_DEPENDS})
-          LIST(APPEND PACKAGE_DEPENDS ${${dependency}_PACKAGE_DEPENDS})
-        ELSE(${dependency}_IS_ENABLED)
-          LIST(APPEND ${RESULT_VAR} ${dependency})
-          LIST(REMOVE_DUPLICATES ${RESULT_VAR})
-        ENDIF(${dependency}_IS_ENABLED)
-      ELSE(NOT _index EQUAL -1)
-        STRING(TOLOWER ${_dependency_file_name} _lowercase_dependency_file_name)
-        LIST(FIND _ALL_MODULES_LOWERCASE ${_lowercase_dependency_file_name} _index_lower)
-        IF(NOT _index_lower EQUAL -1)
-          LIST(GET _ALL_MODULES ${_index_lower} _real_module_name)
-          STRING(REPLACE "Config.cmake" "" _real_module_name ${_real_module_name})
-          MESSAGE("Warning: case mismatch for module name ${dependency}, did you mean ${_real_module_name} ?")
-        ENDIF(NOT _index_lower EQUAL -1)
-        LIST(APPEND ${RESULT_VAR} ${dependency})
-        LIST(REMOVE_DUPLICATES ${RESULT_VAR})
-      ENDIF(NOT _index EQUAL -1)
-
-    ENDFOREACH(dependency) 
-    LIST(REMOVE_DUPLICATES DEPENDS)
-    LIST(REMOVE_DUPLICATES PACKAGE_DEPENDS)
-    LIST(SORT DEPENDS)
-    LIST(SORT PACKAGE_DEPENDS)
-  ENDWHILE()
-  
-  FOREACH(_package PACKAGE_DEPENDS)
-    IF((DEFINED RTTB_USE_${_package}) AND NOT (${RTTB_USE_${_package}}))
-      LIST(APPEND ${RESULT_VAR} ${_package})
-    ENDIF()  
-  ENDFOREACH()
-
-ENDMACRO(RTTB_CHECK_MODULE)
diff --git a/cmake/rttbMacroCreateModule.cmake b/cmake/rttbMacroCreateModule.cmake
deleted file mode 100644
index 7ca3219..0000000
--- a/cmake/rttbMacroCreateModule.cmake
+++ /dev/null
@@ -1,118 +0,0 @@
-##################################################################
-#
-# RTTB_CREATE_MODULE 
-#
-#! Creates a module for the automatic module dependency system within RTTB.
-#! Configurations are generated in the moduleConf directory. 
-#!
-#! USAGE:
-#!
-#! \code
-#! RTTB_CREATE_MODULE( <moduleName>
-#!     [INCLUDE_DIRS <include directories>]
-#!     [INTERNAL_INCLUDE_DIRS <internally used include directories>]
-#!     [DEPENDS <modules we need>]
-#!     [PROVIDES <library name which is built>]
-#!     [PACKAGE_DEPENDS <packages we need, like ITK, VTK, QT>]
-#!     [EXPORT_DEFINE <declspec macro name for dll exports>]
-#! \endcode
-#!
-#! \param MODULE_NAME_IN The name for the new module
-#
-##################################################################
-MACRO(RTTB_CREATE_MODULE MODULE_NAME_IN)
-  MACRO_PARSE_ARGUMENTS(MODULE
-                        "INCLUDE_DIRS;INTERNAL_INCLUDE_DIRS;DEPENDS;DEPENDS_INTERNAL;PROVIDES;PACKAGE_DEPENDS;EXPORT_DEFINE;ADDITIONAL_LIBS"
-                        "FORCE_STATIC;HEADERS_ONLY"
-                        ${ARGN})
-                        
-  SET(MODULE_NAME ${MODULE_NAME_IN})
-  
-  # assume worst case
-  SET(MODULE_IS_ENABLED 0)
-  # first we check if we have an explicit module build list
-  IF(RTTB_MODULES_TO_BUILD)
-    LIST(FIND RTTB_MODULES_TO_BUILD ${MODULE_NAME} _MOD_INDEX)
-    IF(_MOD_INDEX EQUAL -1)
-      SET(MODULE_IS_EXCLUDED 1)
-    ENDIF()
-  ENDIF()
-
-  IF(NOT MODULE_IS_EXCLUDED)
-    MESSAGE(STATUS "configuring Module ${MODULE_NAME}...") 
-    # first of all we check for the dependencies
-    RTTB_CHECK_MODULE(_MISSING_DEP ${MODULE_DEPENDS})
-    IF(_MISSING_DEP)
-      MESSAGE("Module ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}") 
-      SET(MODULE_IS_ENABLED 0)
-    ELSE(_MISSING_DEP)
-      SET(MODULE_IS_ENABLED 1)
-      # now check for every package if it is enabled. This overlaps a bit with
-      # RTTB_CHECK_MODULE ... 
-      FOREACH(_package ${MODULE_PACKAGE_DEPENDS})
-        IF((DEFINED RTTB_USE_${_package}) AND NOT (RTTB_USE_${_package}))
-          MESSAGE("Module ${MODULE_NAME} won't be built. Turn on RTTB_USE_${_package} if you want to use it.")
-		  SET(MODULE_IS_ENABLED 0)
-	    ENDIF()  
-      ENDFOREACH()
-
-      IF(MODULE_IS_ENABLED)
-	     SET(MODULE_IS_ENABLED 1)
-	     _RTTB_CREATE_MODULE_CONF()
-	  IF(NOT MODULE_EXPORT_DEFINE)
-	    SET(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT)
-	  ENDIF(NOT MODULE_EXPORT_DEFINE)
-	  
-	  CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/moduleExports.h.in ${RTTB_MODULES_CONF_DIR}/${MODULE_NAME}Exports.h @ONLY)
-	
-	  SET(DEPENDS "${MODULE_DEPENDS}") 
-	  SET(DEPENDS_BEFORE "not initialized")
-	  SET(PACKAGE_DEPENDS "${MODULE_PACKAGE_DEPENDS}")
-	  RTTB_USE_MODULE("${MODULE_DEPENDS}") 
-	
-	  # ok, now create the module itself 
-	  INCLUDE_DIRECTORIES(. ${ALL_INCLUDE_DIRECTORIES})
-	  INCLUDE(files.cmake)
-	  
-	  ORGANIZE_SOURCES(SOURCE ${CPP_FILES}
-			     HEADER ${H_FILES}
-			     TXX ${TXX_FILES}
-			     DOC ${DOX_FILES}
-			     )
-
-	  IF(MODULE_FORCE_STATIC)
-	    SET(_STATIC ${RTTB_WIN32_FORCE_STATIC})
-	  ENDIF(MODULE_FORCE_STATIC)
-    
-	  IF(NOT MODULE_HEADERS_ONLY)
-        IF(ALL_LIBRARY_DIRS)
-		  # LINK_DIRECTORIES applies only to targets which are added after the call to LINK_DIRECTORIES
-		  LINK_DIRECTORIES(${ALL_LIBRARY_DIRS})
-        ENDIF(ALL_LIBRARY_DIRS)
-     
-	    SET(coverage_sources ${CPP_FILES} ${H_FILES} ${TXX_FILES})
-	    SET_PROPERTY(SOURCE ${coverage_sources} APPEND PROPERTY LABELS ${MODULE_SUBPROJECTS})
-
-	   ADD_LIBRARY(${MODULE_PROVIDES} ${_STATIC} ${coverage_sources} ${CPP_FILES_GENERATED})
-	    
-       SET_TARGET_PROPERTIES(${MODULE_PROVIDES} PROPERTIES ${RTToolbox_LIBRARY_PROPERTIES} OUTPUT_NAME ${MODULE_PROVIDES}-${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR} OUTPUT_NAME_DEBUG ${MODULE_PROVIDES}-D-${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR})		
-       EXPORT(TARGETS ${MODULE_PROVIDES} APPEND FILE ${RTToolbox_TARGETS_FILE})
-
-       INSTALL(TARGETS ${MODULE_PROVIDES} EXPORT RTToolboxExport
-         RUNTIME DESTINATION ${RTTOOLBOX_INSTALL_BIN_DIR} COMPONENT RuntimeLibraries
-         LIBRARY DESTINATION ${RTTOOLBOX_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
-         ARCHIVE DESTINATION ${RTTOOLBOX_INSTALL_LIB_DIR} COMPONENT Development)
-  
-        IF(ALL_LIBRARIES)
-          TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${ALL_LIBRARIES})
-        ENDIF(ALL_LIBRARIES)  
-	  ENDIF()
-	  
-      ENDIF(MODULE_IS_ENABLED)
-    ENDIF(_MISSING_DEP)
-  ENDIF(NOT MODULE_IS_EXCLUDED)
-    
-  IF(NOT MODULE_IS_ENABLED)   
-    _RTTB_CREATE_MODULE_CONF()
-  ENDIF(NOT MODULE_IS_ENABLED)   
-ENDMACRO(RTTB_CREATE_MODULE)
diff --git a/cmake/rttbMacroUseModule.cmake b/cmake/rttbMacroUseModule.cmake
deleted file mode 100644
index 6c43016..0000000
--- a/cmake/rttbMacroUseModule.cmake
+++ /dev/null
@@ -1,65 +0,0 @@
-# Usage: RTTB_USE_MODULE([dependencies ...] )
-# loads module config files of all dependencies specified.
-MACRO(RTTB_USE_MODULE)
-  SET(DEPENDS "")
-  SET(DEPENDS_BEFORE "not initialized")
-  
-  # check for each parameter if it is a package (3rd party)
-  FOREACH(package ${ARGN})
-    SET(is_package)
-    FOREACH(dir ${MODULES_PACKAGE_DEPENDS_DIRS})
-      IF(EXISTS "${dir}/RTTB_${package}_Config.cmake") 
-        LIST(APPEND PACKAGE_DEPENDS ${package})
-        SET(is_package 1)
-        BREAK()
-      ENDIF()
-    ENDFOREACH()
-    IF(NOT is_package)
-      LIST(APPEND DEPENDS ${package}) 
-    ENDIF()
-  ENDFOREACH(package)
-  
-  # go through all module dependencies and get there dependencies for modules and packages
-  WHILE(NOT "${DEPENDS}" STREQUAL "${DEPENDS_BEFORE}")
-    SET(DEPENDS_BEFORE ${DEPENDS})
-    FOREACH(dependency ${DEPENDS})
-      INCLUDE(${RTTB_MODULES_CONF_DIR}/${dependency}Config.cmake)
-      LIST(APPEND DEPENDS ${${dependency}_DEPENDS})
-      LIST(APPEND PACKAGE_DEPENDS ${${dependency}_PACKAGE_DEPENDS})
-    ENDFOREACH(dependency) 
-    IF(DEPENDS)
-      LIST(REMOVE_DUPLICATES DEPENDS)
-      LIST(SORT DEPENDS)
-    ENDIF(DEPENDS)
-    IF(PACKAGE_DEPENDS)
-      LIST(REMOVE_DUPLICATES PACKAGE_DEPENDS)
-      LIST(SORT PACKAGE_DEPENDS)
-    ENDIF(PACKAGE_DEPENDS)
-  ENDWHILE()
-  
-  # now go through all module dependencies and get dirs and libraries
-  FOREACH(dependency ${DEPENDS} ${MODULE_DEPENDS_INTERNAL})
-    INCLUDE(${RTTB_MODULES_CONF_DIR}/${dependency}Config.cmake)
-    SET(ALL_INCLUDE_DIRECTORIES ${ALL_INCLUDE_DIRECTORIES} ${${dependency}_INCLUDE_DIRS})
-    SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${${dependency}_PROVIDES})
-    SET(ALL_LIBRARY_DIRS ${ALL_LIBRARY_DIRS} ${${dependency}_LIBRARY_DIRS})
-  ENDFOREACH(dependency)
-
-  # now go through all package dependencies and include there config file
-  FOREACH(package ${PACKAGE_DEPENDS})
-    FOREACH(dir ${MODULES_PACKAGE_DEPENDS_DIRS})
-      IF(EXISTS "${dir}/RTTB_${package}_Config.cmake")
-        INCLUDE("${dir}/RTTB_${package}_Config.cmake")
-        BREAK()
-      ENDIF()
-    ENDFOREACH()
-  ENDFOREACH(package)
-
-  SET(ALL_LIBRARIES ${ALL_LIBRARIES} ${MODULE_ADDITIONAL_LIBS})
-  SET(ALL_INCLUDE_DIRECTORIES ${ALL_INCLUDE_DIRECTORIES} ${MODULE_INCLUDE_DIRS} ${MODULE_INTERNAL_INCLUDE_DIRS} ${RTTB_MODULES_CONF_DIR})
-
-  IF(ALL_LIBRARY_DIRS)
-    LIST(REMOVE_DUPLICATES ALL_LIBRARY_DIRS)
-  ENDIF(ALL_LIBRARY_DIRS)
-
-ENDMACRO(RTTB_USE_MODULE)
diff --git a/code/algorithms/CMakeLists.txt b/code/algorithms/CMakeLists.txt
index 6178418..9cda14e 100644
--- a/code/algorithms/CMakeLists.txt
+++ b/code/algorithms/CMakeLists.txt
@@ -1,2 +1,2 @@
-RTTB_CREATE_MODULE(RTTBAlgorithms DEPENDS RTTBCore PACKAGE_DEPENDS Boost)
-
+RTTB_CREATE_MODULE(RTTBAlgorithms
+                   DEPENDS PUBLIC RTTBCore)
diff --git a/code/core/CMakeLists.txt b/code/core/CMakeLists.txt
index eb85b02..e240faf 100644
--- a/code/core/CMakeLists.txt
+++ b/code/core/CMakeLists.txt
@@ -1,2 +1,4 @@
-RTTB_CREATE_MODULE(RTTBCore PACKAGE_DEPENDS BoostBinaries)
-
+RTTB_CREATE_MODULE(RTTBCore
+                   PACKAGE_DEPENDS
+                     PUBLIC Boost|headers
+                     PRIVATE Boost|filesystem)
diff --git a/code/indices/CMakeLists.txt b/code/indices/CMakeLists.txt
index bdb24cc..ddb0812 100644
--- a/code/indices/CMakeLists.txt
+++ b/code/indices/CMakeLists.txt
@@ -1 +1,2 @@
-RTTB_CREATE_MODULE(RTTBIndices DEPENDS RTTBCore PACKAGE_DEPENDS Boost)
\ No newline at end of file
+RTTB_CREATE_MODULE(RTTBIndices
+                     DEPENDS PUBLIC RTTBCore)
\ No newline at end of file
diff --git a/code/interpolation/CMakeLists.txt b/code/interpolation/CMakeLists.txt
index bd08f77..9db8a69 100644
--- a/code/interpolation/CMakeLists.txt
+++ b/code/interpolation/CMakeLists.txt
@@ -1,11 +1,11 @@
-RTTB_CREATE_MODULE(RTTBInterpolation DEPENDS RTTBCore PACKAGE_DEPENDS Boost)
+RTTB_CREATE_MODULE(RTTBInterpolation DEPENDS PUBLIC RTTBCore)
 
 ADD_SUBDIRECTORY(ITKTransformation)
 
 OPTION(BUILD_InterpolationMatchPointTransformation
 	   "Determine if the MatchPoint transformation for dose interpolation classes will be generated." OFF)
 IF(BUILD_All_Modules OR BUILD_InterpolationMatchPointTransformation)
 	ADD_SUBDIRECTORY(MatchPointTransformation)
 	SET(BUILD_InterpolationMatchPointTransformation ON CACHE BOOL ON FORCE)
 ENDIF()
 
diff --git a/code/interpolation/ITKTransformation/CMakeLists.txt b/code/interpolation/ITKTransformation/CMakeLists.txt
index 1a2fbb4..ca64739 100644
--- a/code/interpolation/ITKTransformation/CMakeLists.txt
+++ b/code/interpolation/ITKTransformation/CMakeLists.txt
@@ -1 +1,2 @@
-RTTB_CREATE_MODULE(RTTBInterpolationITKTransformation DEPENDS RTTBCore RTTBInterpolation RTTBITKIO PACKAGE_DEPENDS Boost ITK)
\ No newline at end of file
+RTTB_CREATE_MODULE(RTTBInterpolationITKTransformation
+                     DEPENDS PUBLIC RTTBCore RTTBInterpolation RTTBITKIO PACKAGE_DEPENDS PUBLIC ITK)
\ No newline at end of file
diff --git a/code/interpolation/MatchPointTransformation/CMakeLists.txt b/code/interpolation/MatchPointTransformation/CMakeLists.txt
index efe5fd1..b2956f5 100644
--- a/code/interpolation/MatchPointTransformation/CMakeLists.txt
+++ b/code/interpolation/MatchPointTransformation/CMakeLists.txt
@@ -1,2 +1,2 @@
-RTTB_CREATE_MODULE(RTTBInterpolationMatchPointTransformation DEPENDS RTTBCore RTTBInterpolation PACKAGE_DEPENDS Boost MatchPoint ITK)
+RTTB_CREATE_MODULE(RTTBInterpolationMatchPointTransformation DEPENDS PUBLIC RTTBCore RTTBInterpolation PACKAGE_DEPENDS PUBLIC MatchPoint ITK)
 
diff --git a/code/io/dicom/CMakeLists.txt b/code/io/dicom/CMakeLists.txt
index 58e76b5..ca7dd15 100644
--- a/code/io/dicom/CMakeLists.txt
+++ b/code/io/dicom/CMakeLists.txt
@@ -1,2 +1 @@
-RTTB_CREATE_MODULE(RTTBDicomIO DEPENDS RTTBCore RTTBAlgorithms PACKAGE_DEPENDS BoostBinaries DCMTK)
-
+RTTB_CREATE_MODULE(RTTBDicomIO DEPENDS PUBLIC RTTBCore RTTBAlgorithms PACKAGE_DEPENDS PUBLIC DCMTK PRIVATE Boost|filesystem)
diff --git a/code/io/itk/CMakeLists.txt b/code/io/itk/CMakeLists.txt
index 5a01901..5b27e61 100644
--- a/code/io/itk/CMakeLists.txt
+++ b/code/io/itk/CMakeLists.txt
@@ -1,9 +1,9 @@
 IF(RTTB_ITK5_SUPPORT)
   SET(ITK_DEPENDENT_HEADER_FILES "ITK5/itkDoseAccessorImageFilter.h" "ITK5/itkMaskAccessorImageSource.h" )
   SET(ITK_DEPENDENT_SOURCE_FILES "ITK5/itkDoseAccessorImageFilter.cpp" "ITK5/itkMaskAccessorImageSource.cpp")
-  RTTB_CREATE_MODULE(RTTBITKIO INTERNAL_INCLUDE_DIRS ITK5 DEPENDS RTTBCore PACKAGE_DEPENDS Boost ITK)
+  RTTB_CREATE_MODULE(RTTBITKIO INCLUDE_DIRS PRIVATE ITK5 DEPENDS PUBLIC RTTBCore PACKAGE_DEPENDS PUBLIC ITK)
 ELSE()
   SET(ITK_DEPENDENT_HEADER_FILES "ITK4/itkDoseAccessorImageFilter.h" "ITK4/itkMaskAccessorImageSource.h")
   SET(ITK_DEPENDENT_SOURCE_FILES "ITK4/itkDoseAccessorImageFilter.cpp" "ITK4/itkMaskAccessorImageSource.cpp")
-  RTTB_CREATE_MODULE(RTTBITKIO INTERNAL_INCLUDE_DIRS ITK4 DEPENDS RTTBCore PACKAGE_DEPENDS Boost ITK)
+  RTTB_CREATE_MODULE(RTTBITKIO INCLUDE_DIRS PRIVATE ITK4 DEPENDS PUBLIC RTTBCore PACKAGE_DEPENDS PUBLIC ITK)
 ENDIF()
\ No newline at end of file
diff --git a/code/io/models/CMakeLists.txt b/code/io/models/CMakeLists.txt
index 3f6de7d..03dfcf9 100644
--- a/code/io/models/CMakeLists.txt
+++ b/code/io/models/CMakeLists.txt
@@ -1,2 +1,2 @@
-RTTB_CREATE_MODULE(RTTBModelsIO DEPENDS RTTBCore RTTBModels RTTBOtherIO RTTBAlgorithms PACKAGE_DEPENDS Boost)
+RTTB_CREATE_MODULE(RTTBModelsIO DEPENDS RTTBCore RTTBModels RTTBOtherIO RTTBAlgorithms PACKAGE_DEPENDS PRIVATE Boost|filesystem)
 
diff --git a/code/masks/CMakeLists.txt b/code/masks/CMakeLists.txt
index a107409..544aec1 100644
--- a/code/masks/CMakeLists.txt
+++ b/code/masks/CMakeLists.txt
@@ -1,7 +1,5 @@
-MESSAGE (STATUS "processing RTToolbox boost mask")
-
-RTTB_CREATE_MODULE(RTTBMask DEPENDS RTTBCore PACKAGE_DEPENDS BoostBinaries)
+RTTB_CREATE_MODULE(RTTBMask DEPENDS PUBLIC RTTBCore)
 
 IF (CMAKE_COMPILER_IS_GNUCC)
 	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fext-numeric-literals")
 ENDIF()
diff --git a/code/models/CMakeLists.txt b/code/models/CMakeLists.txt
index b7cc625..4479756 100644
--- a/code/models/CMakeLists.txt
+++ b/code/models/CMakeLists.txt
@@ -1,2 +1,2 @@
-RTTB_CREATE_MODULE(RTTBModels DEPENDS RTTBCore PACKAGE_DEPENDS Boost)
+RTTB_CREATE_MODULE(RTTBModels DEPENDS PUBLIC RTTBCore)