diff --git a/README.md b/README.md
index 156074b..0956754 100644
--- a/README.md
+++ b/README.md
@@ -1,272 +1,271 @@
 
 # RTToolbox
 
 RTToolbox is a software library to support quantitative analysis of treatment outcome for radiotherapy.
 
 The RTToolbox was designed following object-oriented design (OOD) principles and was implemented in the language C++. 
 
 Features include:
 
 * import of radiotherapy data (e.g. dose distributions and structure sets) from DICOM-RT format and other standard image processing formats
 * DVH calculation
 * Dose statistic calculation
 * arithmetic operations on dose distributions
 * structure relationship analyses (e.g. fully-contained, partially-contained)
 * Calculation of dose comparison indices such as Conformity Index (CI), Homogeneity Index (HI) and Conformation Number (CN)
 * Calculation of biological models including TCP, NTCP, EUD and BED
 
 Also, the RTToolbox provides apps e.g. for DVH/Dose Statistic calculation or Dose accumulation that provides a convenient access of RT scenarios without computer-science knowledge.
 
 ## Getting Started
 
 These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.
 
 ### Prerequisites
 
 #### Build system
 
 * [CMake](https://cmake.org), version 3.1 or higher
 
 #### Compiler
 
 * Visual Studio 2013
 * Visual Studio 2015
 * Visual Studio 2017
 * GCC 5.4
 * GCC 7.3
 
 Other compilers may work as well, but are not tested.
 
 #### Linking Static/Dynamic library support
 
 Can be changed with advanced option `BUILD_SHARED_LIBS`
 
 :warning: building RTToolbox as dynamic library under Windows and as static library under Linux is an experimental feature.
 
 #### Third party libraries
 
 * [boost](http://www.boost.org ), version 1.64.0 or higher
 * [DCMTK](http://dicom.offis.de/dcmtk.php.en ), with RT support - 3.6.1_20121102 or newer
 * [ITK](https://itk.org ), version 4.4 or higher (*optional*)
   * for DoseInterpolation support with ITK transformation or ITK File IO support
 * [MatchPoint](http://mitk.org/download/thirdparty/MatchPoint_rev1610.tar.gz ), version 0.12 or higher (*optional*)
   * for DoseInterpolation support with MatchPoint registration objects
 
 :information_source: To make sure everything runs smoothly, please make sure that all libraries and the RTToolbox are either compiled with `/MD` or `/MT` flags.
 
 ##### Boost
 
 In case you work with Windows, we recommend using the [pre-build versions of boost](https://sourceforge.net/projects/boost/files/boost-binaries/).
 
 If you want to build the library yourself, consider the following:
 
 Build (using the same compiler options as RTToolbox, usually `STATIC LINKING` and `x64` architecture). 
 The following components are needed: 
 
 * `filesystem`, 
-* `system`, 
-* `thread` and 
+* `system` and
 * `program_options` 
   * if you plan to build the apps (*optional*)
 
 :information_source: eventually, it might be needed to add the CMake variable `BOOST_LIBRARYDIR` and set it to the respective library path of boost.
 
 For Windows:
 
 To build Boost open a command prompt, change to your boost source directory and copy following command(s):
 Debug:
 `b2 -j12 --with-filesystem --with-system --with-thread --with-program_options --with-date_time --with-atomic --with-chrono toolset=msvc-14.1 address-model=64 variant=debug threading=multi link=shared define=_BIND_TO_CURRENT_VCLIBS_VERSION`
 Release:
 `b2 -j12 --with-filesystem --with-system --with-thread --with-program_options --with-date_time --with-atomic --with-chrono toolset=msvc-14.1 address-model=64 variant=release threading=multi link=shared`
 
 If you don´t require `program_options` delete `--with-program_options` from the command before executing it.
 ##### DCMTK
 
 For Windows:
 
 To compile DCMTK with `/MD` flags (standard for all other libs), you need to patch the CMAKE options of DCMTK (`PathToDCMTK\CMake\dcmtkPrepare.cmake`), either by replacing `"/MT"` with `"/MD"` or by explicitly replacing lines 135 to 171 with the following lines:
 
 ```
 IF(DCMTK_OVERWRITE_WIN32_COMPILER_FLAGS AND NOT BUILD_SHARED_LIBS)
 
   
 	# settings for Microsoft Visual Studio
   
 	IF(CMAKE_GENERATOR MATCHES "Visual Studio .*")
     
 		# get Visual Studio Version
     
 		STRING(REGEX REPLACE "Visual Studio ([0-9]+).*" "\\1" VS_VERSION "${CMAKE_GENERATOR}")
     
 		# these settings never change even for C or C++
     
 		SET(CMAKE_C_FLAGS_DEBUG "/MDd /Z7 /Od")
     
 		SET(CMAKE_C_FLAGS_RELEASE "/DNDEBUG /MD /O2")
     
 		SET(CMAKE_C_FLAGS_MINSIZEREL "/DNDEBUG /MD /O2")
     
 		SET(CMAKE_C_FLAGS_RELWITHDEBINFO "/DNDEBUG /MDd /Z7 /Od")
 
     
 		SET(CMAKE_CXX_FLAGS_DEBUG "/MDd /Z7 /Od")
     
 		SET(CMAKE_CXX_FLAGS_RELEASE "/DNDEBUG /MD /O2")
     
 		SET(CMAKE_CXX_FLAGS_MINSIZEREL "/DNDEBUG /MD /O2")
     
 		SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/DNDEBUG /MDd /Z7 /Od")
     
 		# specific settings for the various Visual Studio versions
     
 		IF(VS_VERSION EQUAL 6)
       
 			SET(CMAKE_C_FLAGS "/nologo /W3 /GX /Gy /YX")
       
 			SET(CMAKE_CXX_FLAGS "/nologo /W3 /GX /Gy /YX /Zm500") # /Zm500 increments heap size which is needed on some system to compile templates in dcmimgle
     
 		ENDIF(VS_VERSION EQUAL 6)
     
 		IF(VS_VERSION EQUAL 7)
       
 			SET(CMAKE_C_FLAGS "/nologo /W3 /Gy")
       
 			SET(CMAKE_CXX_FLAGS "/nologo /W3 /Gy")
     
 		ENDIF(VS_VERSION EQUAL 7)
     
 		IF(VS_VERSION GREATER 7)
       
 			SET(CMAKE_C_FLAGS "/nologo /W3 /Gy /EHsc")
       
 			SET(CMAKE_CXX_FLAGS "/nologo /W3 /Gy /EHsc")
     
 		ENDIF(VS_VERSION GREATER 7)
   
 	ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio .*")
 
 
 ENDIF(DCMTK_OVERWRITE_WIN32_COMPILER_FLAGS AND NOT BUILD_SHARED_LIBS)
 ```
 
 `BUILD_APPS` can be switched off.
 Then build DCMTK.
 
 For Linux:
 install required dependencies (Ubuntu 18.04 and newer): `sudo apt-get install libpng-dev libtiff5-dev libxml2-dev libjpeg8-dev zlib1g-dev libwrap0-dev libssl-dev`
 install required dependencies (Ubuntu 17.10 and older): `sudo apt-get install libpng12-dev libtiff5-dev libxml2-dev libjpeg8-dev zlib1g-dev libwrap0-dev libssl-dev`
 Enable `BUILD_SHARED_LIBS`. `BUILD_APPS` can be switched off.
 
 ##### ITK
 
 Build ITK with default options.
 :warning: ensure that compiler enables C++11 features by setting `CMAKE_CXX_STANDARD=11` (default for supported compilers)
 
 :warning: if you use ITK 5, turn on `RTTB_ITK5_SUPPORT`
 
 :warning: Only use one ITK version consistently throughout all libraries and RTToolbox! Otherwise, linker errors will occur.
 
 ##### MatchPoint
 
 Configure MatchPoint. Please disable `BUILD_TESTING` before building it.
 :warning: ensure that compiler enables C++11 features by setting `CMAKE_CXX_STANDARD=11` (default for supported compilers)
 
 :warning: Only use one ITK version consistently throughout all libraries and RTToolbox! Otherwise, linker errors will occur.
 
 :warning: MatchPoint currently does not support ITK 5
 
 ### Building RT-Toolbox
 
 * Configure with CMake
 * Set `BOOST_INCLUDE_DIR` to the main boost directory. Eventually set `BOOST_LIBRARYDIR` to the respective path (e.g. `<boost_directory>/lib64-msvc-14.1\` for Visual Studio 2017 and 64-bit)
 * Select all packages you like to build (Parameters `BUILD_*` ; e.g. `BUILD_IO_Dicom`). 
   * `BUILD_IO_Dicom`: Reading and writing of DICOM-RT files
   * `BUILD_IO_HELAX`: Reading of Helax DICOM files
   * `BUILD_IO_ITK`: Generic reading/writing with ITK
   * `BUILD_Interpolation`: Dose Interpolation
   * `BUILD_InterpolationMatchPointTransformation`: Dose Interpolation with Match Point registration support.
   * `BUILD_Masks`: Voxelization support
   * `BUILD_Models`: Calculation of dosimetrical models like TCP, NTCP etc.
   * `BUILD_Apps`: To build the RTTB command line apps (five available)
     * `BioModelCalc`: calculate the radiobiological effect based on dose
 	* `DoseAcc`: Do dose accumulation
 	* `DoseMap`: Do dose mapping
 	* `DoseTool`: Compute Dose statistics and DVH
 	* `VoxelizerTool`: Voxelize an RTSTRUCT file
 	
 Some modules of RT-Toolbox are mandatory (e.g. `RTTBCore`) and build automatically.
 		
 :information_source: enabling `BUILD_All_Modules` builds all modules (except Apps and Testing modules).
 
 :information_source: if you build RTTB with VS dynamic, you must ensure that code that uses RTTB DLLs uses the same STL
 
 
 Set `DCMTK_DIR` to your dcmtk binary file directory and `DCMTK_SOURCE_DIR` to your dcmtk source directory.
 
 If you want to build RT-Toolbox with ITK and/or MatchPoint set your `ITK_DIR` to your itk binary file directory and/or `MatchPoint_DIR` to your binary matchpoint directory.
 
 All directory entries left empty do not require a manual input.
 
 Finally, Generate the compilation files for your environment and built it.
 
 ### Examples 
 
 Some examples can be found in ´testing/examples´:
 
 * `RTBioModelExampleTest`: Computation of Biological model indices (TCP/NTCP) from a given DVH
 * `RTDoseIndexTest`: Computation of dose indices (Conformation Number, Conformal Index, Conformity index) from a given DVH
 * `RTDoseStatisticsDicomTest`: Computation of dose statistics (max dose/mean dose/min dose/Dx/Vx) based on dose data for a specified structure
 * `RTDVHTest`: Computation of statistics (max value/mean value/min value/Dx/Vx) based on a DVH
 
 Other examples include:
 
 * `DVHCalculatorTest` (`testing/core`): Computation of a DVH from dose and structure
 * `VoxelizationValidationTest` (`testing/validation`): Computation of a voxelization
 * `ITKDoseAccessorConverterTest`: (`testing/io/itk`): Saving image RTToolbox image data as an ITK file
 
 ## Running the tests
 
 [CTest](https://cmake.org/Wiki/CMake/Testing_With_CTest) is used as testing framework. See their documentation for general testing questions.
 
 :information_source: The used testing library Litmus is build automatically. 
 
 :warning: currently, you have access to testing data only with ssh. That means that a [phabricator](https://phabricator.mitk.org/) account and access to `RTTB-data` repository is mandatory. Please contact rttb(at)dkfz.de for further information.
 
 Enabling testing is done as follows:
 
 * Enable `BUILD_TESTING`
 * Configure with CMake
 * Enable tests of interest
 * Generate CMake configuration
 * Build RT-Toolbox
 * Run tests (build `RUN_TESTS` project or call `ctest` in commandline) to ensure that everything is correct.
 
 :information_source: `BUILD_Tester_All` builds all test modules.
 
 ## Contributing
 
 Please add a github issue and send a pull request if you want to contribute.
 
 ## Versioning
 
 We use the Ubuntu Release versioning scheme. v2017.02 was released in February 2017. We aim at releasing stable versions once a year. For the versions available, see the [tags on this repository](https://github.com/MIC-DKFZ/RTTB/tags). 
 
 ## Authors
 
 See the list of [contributors](https://github.com/MIC-DKFZ/RTTB/contributors) who participated in this project.
 
 ## License
 
 This project is licensed under the BSD License - see the [LICENSE](LICENSE) file for details
 
 ## Contact
 
 Software Development for Integrated Diagnostics and Therapy (SIDT),
 German Cancer Research Center (DKFZ), Heidelberg, Germany.
 
 Web:    https://www.dkfz-heidelberg.de/en/mic/research/SIDT/sidt_projects.html
 E-mail: rttb(at)dkfz.de
 
 ## Acknowledgments
 
 * **Billie Thompson** - *Template of the readme* - [PurpleBooth](https://github.com/PurpleBooth)
diff --git a/documentation/RTToolbox_build.txt b/documentation/RTToolbox_build.txt
index 189236b..3c1e069 100644
--- a/documentation/RTToolbox_build.txt
+++ b/documentation/RTToolbox_build.txt
@@ -1,209 +1,208 @@
 /**
 \page Build Build instructions
 
 \tableofcontents
 
 \section tests Compiler tests
 
 RTToolbox is currently tested with the following compilers (only x64):
 - Visual Studio 2013
 - Visual Studio 2015
 - GCC 5.4
 
 Other compiler versions or other compilers may or may not work. 
 \note The apps can't be compiled with Visual Studio 2010.
 
 \section linking Static/Dynamic library support
 
 Can be changed with advanced option \c BUILD_SHARED_LIBS
 
 \warning building RTToolbox as dynamic library under windows and as static library under Linux is an experimental feature.
 
 \section thirdPartyLibraries Needed Third Party Libraries
 
 Please load and compile the following third party libraries/tools:
 
 \subsection required Required
 - <a href="https://cmake.org">CMake</a>  (version 3.1 or higher)
 - <a href="http://www.boost.org">boost</a> (version 1.64.0 or higher)
 
 \subsection optional Optional
 - <a href="http://dicom.offis.de/dcmtk.php.en">DCMTK</a> (with RT support - 3.6.1_20121102 or newer)
   - if you want DICOM support
 - <a href="https://itk.org">ITK</a> (version 4.4 or higher)
   - if you want DoseInterpolation support with \c itk::Transform or ITK File IO support
 - <a href="http://mitk.org/download/thirdparty/MatchPoint_rev1610.tar.gz">MatchPoint</a> (version 0.12 or higher)
   - if you want DoseInterpolation support with MatchPoint Registration objects)
 - <a href="https://www.doxygen.org">doxygen</a>
   - if you want to generate a source code documentation
 
 \subsection installing Third party installation Instruction
 
 \note To make sure everything runs smoothly, please make sure that all libraries and the RTToolbox are either compiled with \c /MD or \c /MT flags.
 
 If third party library packages cannot be found automatically, CMake will ask for them. Please give the location of the binary folder, where the libraries where built for boost, DCMTK, ITK and MatchPoint.
 
 \subsubsection boost Boost
 
 Build (using the same compiler options as RTToolbox, usually \c STATIC LINKING and x64 architecture). 
 The following components are needed: 
 - \c filesystem, 
-- \c system, 
-- \c thread and 
+- \c system and
 - \c program_options if you plan to build the apps.
 
 \note eventually, it might be needed to add the CMake variable BOOST_LIBRARY dir and set it to the respective library.
 
 \subsubsection DCMTK DCMTK
 
 For Windows:
 
 To compile DCMTK with \c /MD flags (standard for all other libs), you need to patch the CMAKE options of DCMTK (PathToDCMTK\CMake\dcmtkPrepare.cmake), either by replacing \c "/MT" with \c "/MD" or by explicitly replacing lines 253 to 283 with the following lines:
 
 \code{.cmake} 
 IF(DCMTK_OVERWRITE_WIN32_COMPILER_FLAGS AND NOT BUILD_SHARED_LIBS)
 
   
 	# settings for Microsoft Visual Studio
   
 	IF(CMAKE_GENERATOR MATCHES "Visual Studio .*")
     
 		# get Visual Studio Version
     
 		STRING(REGEX REPLACE "Visual Studio ([0-9]+).*" "\\1" VS_VERSION "${CMAKE_GENERATOR}")
     
 		# these settings never change even for C or C++
     
 		SET(CMAKE_C_FLAGS_DEBUG "/MDd /Z7 /Od")
     
 		SET(CMAKE_C_FLAGS_RELEASE "/DNDEBUG /MD /O2")
     
 		SET(CMAKE_C_FLAGS_MINSIZEREL "/DNDEBUG /MD /O2")
     
 		SET(CMAKE_C_FLAGS_RELWITHDEBINFO "/DNDEBUG /MDd /Z7 /Od")
 
     
 		SET(CMAKE_CXX_FLAGS_DEBUG "/MDd /Z7 /Od")
     
 		SET(CMAKE_CXX_FLAGS_RELEASE "/DNDEBUG /MD /O2")
     
 		SET(CMAKE_CXX_FLAGS_MINSIZEREL "/DNDEBUG /MD /O2")
     
 		SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/DNDEBUG /MDd /Z7 /Od")
     
 		# specific settings for the various Visual Studio versions
     
 		IF(VS_VERSION EQUAL 6)
       
 			SET(CMAKE_C_FLAGS "/nologo /W3 /GX /Gy /YX")
       
 			SET(CMAKE_CXX_FLAGS "/nologo /W3 /GX /Gy /YX /Zm500") # /Zm500 increments heap size which is needed on some system to compile templates in dcmimgle
     
 		ENDIF(VS_VERSION EQUAL 6)
     
 		IF(VS_VERSION EQUAL 7)
       
 			SET(CMAKE_C_FLAGS "/nologo /W3 /Gy")
       
 			SET(CMAKE_CXX_FLAGS "/nologo /W3 /Gy")
     
 		ENDIF(VS_VERSION EQUAL 7)
     
 		IF(VS_VERSION GREATER 7)
       
 			SET(CMAKE_C_FLAGS "/nologo /W3 /Gy /EHsc")
       
 			SET(CMAKE_CXX_FLAGS "/nologo /W3 /Gy /EHsc")
     
 		ENDIF(VS_VERSION GREATER 7)
   
 	ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio .*")
 
 
 ENDIF(DCMTK_OVERWRITE_WIN32_COMPILER_FLAGS AND NOT BUILD_SHARED_LIBS)
 \endcode
 
 Then build DCMTK. \c BUILD_APPS can be switched off.
 
 \subsubsection ITK ITK
 
 Build ITK.
 \warning Only use one ITK version consistently throughout all libraries and RTToolbox! Otherwise, linker errors will occur.
 \warning ensure that compiler enables C++11 features by setting CMAKE_CXX_STANDARD=11 (default for supported compilers)
 
 \subsubsection MatchPoint MatchPoint
 
 Build MatchPoint.
 \warning Only use one ITK version consistently throughout all libraries and RTToolbox! Otherwise, linker errors will occur.
 \warning ensure that compiler enables C++11 features by setting CMAKE_CXX_STANDARD=11 (default for supported compilers)
 
 \section installation RT-Toolbox installation Instruction
 
 \subsection build Configure/Build RTToolbox
 
 \subsubsection Modules Modules
 
 - Configure with CMake
 - Set \c BOOST_INCLUDE_DIR and \c BOOST_DIR to the main boost directory (where "boost_build.jam" is located). Eventually, you have to set BOOST_LIBRARYDIR
 - Select all packages you like to build (Parameters \c "BUILD_*" ; e.g. \c BUILD_IO_Dicom). 
 	- \c BUILD_IO_Dicom: Reading and writing of DICOM-RT files
 	- \c BUILD_IO_HELAX: Reading of Helax DICOM files
 	- \c BUILD_IO_ITK: Generic reading/writing with ITK
 	- \c BUILD_Interpolation: Dose Interpolation
 	- \c BUILD_InterpolationMatchPointTransformation: Dose Interpolation with Match Point registration support.
 	- \c BUILD_Masks: Voxelization support
 	- \c BUILD_Masks_Legacy: Legacy voxelization support. 
 	- \c BUILD_Models: Calculation of dosimetrical models like TCP, NTCP etc.
 	
 Some modules of RT-Toolbox are mandatory (e.g. \c RTTBCore) and build automatically.
 	
 \warning The \c BUILD_Masks_Legacy module is not supported anymore and may yield to wrong results.	
 \note enabling \c BUILD_All_Modules builds all modules (except Apps, Testing modules and Masks_Legacy).
 
 \subsubsection Apps Apps
 
 \note The used library ArgumentParsingLib for parsing command line arguments is built automatically.
 	
 If you want to use the RTTB command line apps, select \c BUILD_Apps. You can select out of five apps:
 	- \c BioModelCalc: calculate the radiobiological effect based on dose
 	- \c DoseAcc: Do dose accumulation
 	- \c DoseMap: Do dose mapping
 	- \c DoseTool: Compute Dose statistics and DVH
 	- \c VoxelizerTool: Voxelize an RTSTRUCT file
 
 - Generate CMake configuration
 - Build RTToolbox and have fun!
 
 \subsubsection optionalDependencies Optional third party dependencies
 
 - If you select \c BUILD_IO_DICOM, the configuration will ask you for the DCMTK main directory (parameter \c DCMTK_DIR; where you have built DCMTK).
 - If you select \c BUILD_Interpolation or \c BUILD_IO_ITK, set \c ITK_DIR to the binary directory of ITK.
 - If you select \c BUILD_InterpolationMatchPointTransformation, set \c MatchPoint_DIR to the binary directory of MatchPoint.
 
 \note If you have built DCMTK as out source build you have to also set the CMake parameter \c DCMTK_SOURCE_DIR to the root directory of the DCMTK source.
 
 \subsection testRTTB Testing RTToolbox
 
 <a href="https://cmake.org/Wiki/CMake/Testing_With_CTest">CTest</a> is used as testing framework. See their documentation for general testing questions.
 
 \note The used testing library Litmus is build automatically. 
 \warning currently, you have access to testing data only with ssh. That means that a phabricator account and access to RTTB-data repository is mandatory.
 
 - Enable \c BUILD_TESTING
 - Configure with CMake
 - Enable tests of interest
 - Generate CMake configuration
 - Run tests (build \c RUN_TESTS project or call \c ctest in commandline) to ensure that everything is correct.
 
 \note enabling \c BUILD_Tester_All builds all test modules.
 
 \subsection documentation Documentation
 
 Generate the documentation using <a href="www.doxygen.org">doxygen</a> and the configuration found in "RTTB_binary_dir/documentation/doxygen.config".
 
 \subsection examples Examples
 
 - Enable \c BUILD_TESTING
 - Enable \c BUILD_RTToolbox_Test_examples
 - Run tests (build \c RUN_TESTS project or call \c ctest in commandline) to also run the examples. These examples (located in testing/examples/) are a good starting point for own projects and show basic functionality of RTToolbox like DVH generation.
 **/