diff --git a/BlueBerry/CMake/MacroCreateCTKPlugin.cmake b/BlueBerry/CMake/MacroCreateCTKPlugin.cmake
index 631922fc59..f389342ece 100644
--- a/BlueBerry/CMake/MacroCreateCTKPlugin.cmake
+++ b/BlueBerry/CMake/MacroCreateCTKPlugin.cmake
@@ -1,190 +1,192 @@
 
 #! \brief Creates a CTK plugin.
 #!
 #! This macro should be called from the plugins CMakeLists.txt file.
 #! The target name is available after the macro call as ${PLUGIN_TARGET}
 #! to add additional libraries in your CMakeLists.txt. Include paths and link
 #! libraries are set depending on the value of the Required-Plugins header
 #! in your manifest_headers.cmake file.
 #!
 #! This macro internally calls ctkMacroBuildPlugin() and adds support
 #! for Qt Help files and installers.
 #!
 #! \param EXPORT_DIRECTIVE (required) The export directive to use in the generated
 #!        <plugin_target>_Exports.h file.
 #! \param EXPORTED_INCLUDE_SUFFIXES (optional) a list of sub-directories which should
 #!        be added to the current source directory. The resulting directories
 #!        will be available in the set of include directories of depending plug-ins.
 #! \param DOXYGEN_TAGFILES (optional) Which external tag files should be available for the plugin documentation
+#! \param MOC_OPTIONS (optional) Additional options to pass to the Qt MOC compiler
 #! \param TEST_PLUGIN (option) Mark this plug-in as a testing plug-in.
 #! \param NO_INSTALL (option) Don't install this plug-in.
 macro(MACRO_CREATE_CTK_PLUGIN)
 
-  MACRO_PARSE_ARGUMENTS(_PLUGIN "EXPORT_DIRECTIVE;EXPORTED_INCLUDE_SUFFIXES;DOXYGEN_TAGFILES" "TEST_PLUGIN;NO_INSTALL;NO_QHP_TRANSFORM" ${ARGN})
+  MACRO_PARSE_ARGUMENTS(_PLUGIN "EXPORT_DIRECTIVE;EXPORTED_INCLUDE_SUFFIXES;DOXYGEN_TAGFILES;MOC_OPTIONS" "TEST_PLUGIN;NO_INSTALL;NO_QHP_TRANSFORM" ${ARGN})
 
   message(STATUS "Creating CTK plugin ${PROJECT_NAME}")
 
   set(PLUGIN_TARGET ${PROJECT_NAME})
 
   include(files.cmake)
 
   set(_PLUGIN_CPP_FILES ${CPP_FILES})
   set(_PLUGIN_MOC_H_FILES ${MOC_H_FILES})
   set(_PLUGIN_UI_FILES ${UI_FILES})
   set(_PLUGIN_CACHED_RESOURCE_FILES ${CACHED_RESOURCE_FILES})
   set(_PLUGIN_TRANSLATION_FILES ${TRANSLATION_FILES})
   set(_PLUGIN_QRC_FILES ${QRC_FILES})
   set(_PLUGIN_H_FILES ${H_FILES})
   set(_PLUGIN_TXX_FILES ${TXX_FILES})
   set(_PLUGIN_DOX_FILES ${DOX_FILES})
   set(_PLUGIN_CMAKE_FILES ${CMAKE_FILES} files.cmake)
   set(_PLUGIN_FILE_DEPENDENCIES ${FILE_DEPENDENCIES})
 
   if(CTK_PLUGINS_OUTPUT_DIR)
     set(_output_dir "${CTK_PLUGINS_OUTPUT_DIR}")
   else()
     set(_output_dir "")
   endif()
 
   if(_PLUGIN_TEST_PLUGIN)
     set(is_test_plugin "TEST_PLUGIN")
   else()
     set(is_test_plugin)
   endif()
 
   # Compute the plugin dependencies
   ctkFunctionGetTargetLibraries(_PLUGIN_target_libraries)
 
 
   #------------------------------------------------------------#
   #------------------ Qt Help support -------------------------#
 
   set(PLUGIN_GENERATED_QCH_FILES )
   if(BLUEBERRY_USE_QT_HELP AND
       EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/documentation/UserManual")
     set(PLUGIN_DOXYGEN_INPUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/documentation/UserManual")
     set(PLUGIN_DOXYGEN_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/documentation/UserManual")
 
     # Create a list of Doxygen tag files from the plug-in dependencies
     set(PLUGIN_DOXYGEN_TAGFILES)
     foreach(_dep_target ${_PLUGIN_target_libraries})
       string(REPLACE _ . _dep ${_dep_target})
 
       get_target_property(_is_imported ${_dep_target} IMPORTED)
       if(_is_imported)
         get_target_property(_import_loc_debug ${_dep_target} IMPORTED_LOCATION_DEBUG)
         get_target_property(_import_loc_release ${_dep_target} IMPORTED_LOCATION_RELEASE)
         # There is not necessarily a debug and release build
         if(_import_loc_release)
           set(_import_loc ${_import_loc_release})
         else()
           set(_import_loc ${_import_loc_debug})
         endif()
         get_filename_component(_target_filename "${_import_loc}" NAME)
         # on windows there might be a Debug or Release subdirectory
         string(REGEX REPLACE "/bin/plugins/(Debug/|Release/)?${_target_filename}" "/Plugins/${_dep}/documentation/UserManual" plugin_tag_dir "${_import_loc}" )
       else()
         set(plugin_tag_dir "${CMAKE_BINARY_DIR}/Plugins/${_dep}/documentation/UserManual")
       endif()
 
       set(_tag_file "${plugin_tag_dir}/${_dep_target}.tag")
       if(EXISTS ${_tag_file})
         set(PLUGIN_DOXYGEN_TAGFILES "${PLUGIN_DOXYGEN_TAGFILES} ${_tag_file}=qthelp://${_dep}/bundle/")
       endif()
     endforeach()
     if(_PLUGIN_DOXYGEN_TAGFILES)
       set(PLUGIN_DOXYGEN_TAGFILES "${PLUGIN_DOXYGEN_TAGFILES} ${_PLUGIN_DOXYGEN_TAGFILES}")
     endif()
     #message("PLUGIN_DOXYGEN_TAGFILES: ${PLUGIN_DOXYGEN_TAGFILES}")
 
     if(_PLUGIN_NO_QHP_TRANSFORM)
       set(_use_qhp_xsl 0)
     else()
       set(_use_qhp_xsl 1)
     endif()
     _FUNCTION_CREATE_CTK_QT_COMPRESSED_HELP(PLUGIN_GENERATED_QCH_FILES ${_use_qhp_xsl})
     list(APPEND _PLUGIN_CACHED_RESOURCE_FILES ${PLUGIN_GENERATED_QCH_FILES})
   endif()
 
   #------------------------------------------------------------#
   #------------------ Create Plug-in --------------------------#
 
   ctkMacroBuildPlugin(
     NAME ${PLUGIN_TARGET}
     EXPORT_DIRECTIVE ${_PLUGIN_EXPORT_DIRECTIVE}
     SRCS ${_PLUGIN_CPP_FILES}
     MOC_SRCS ${_PLUGIN_MOC_H_FILES}
+    MOC_OPTIONS ${_PLUGIN_MOC_OPTIONS}
     UI_FORMS ${_PLUGIN_UI_FILES}
     EXPORTED_INCLUDE_SUFFIXES ${_PLUGIN_EXPORTED_INCLUDE_SUFFIXES}
     RESOURCES ${_PLUGIN_QRC_FILES}
     TARGET_LIBRARIES ${_PLUGIN_target_libraries}
     CACHED_RESOURCEFILES ${_PLUGIN_CACHED_RESOURCE_FILES}
     TRANSLATIONS ${_PLUGIN_TRANSLATION_FILES}
     OUTPUT_DIR ${_output_dir}
     ${is_test_plugin}
   )
 
   if(mbilog_FOUND)
     target_link_libraries(${PLUGIN_TARGET} mbilog)
   endif()
 
   include_directories(${Poco_INCLUDE_DIRS})
   include_directories(${BlueBerry_BINARY_DIR})
 
   target_link_libraries(${PLUGIN_TARGET}
     optimized PocoFoundation debug PocoFoundationd
     optimized PocoUtil debug PocoUtild
     optimized PocoXML debug PocoXMLd
   )
 
   # Set compiler flags
   get_target_property(_plugin_compile_flags ${PLUGIN_TARGET} COMPILE_FLAGS)
   if(NOT _plugin_compile_flags)
     set(_plugin_compile_flags "")
   endif()
   if(WIN32)
     set(_plugin_compile_flags "${_plugin_compile_flags} -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN")
   endif()
   set_target_properties(${PLUGIN_TARGET} PROPERTIES COMPILE_FLAGS "${_plugin_compile_flags}")
 
   set(_PLUGIN_META_FILES "${CMAKE_CURRENT_SOURCE_DIR}/manifest_headers.cmake")
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/plugin.xml")
     list(APPEND _PLUGIN_META_FILES "${CMAKE_CURRENT_SOURCE_DIR}/plugin.xml")
   endif()
 
   MACRO_ORGANIZE_SOURCES(
     SOURCE ${_PLUGIN_CPP_FILES}
     HEADER ${_PLUGIN_H_FILES}
     TXX ${_PLUGIN_TXX_FILES}
     DOC ${_PLUGIN_DOX_FILES}
     UI ${_PLUGIN_UI_FILES}
     QRC ${_PLUGIN_QRC_FILES} ${_PLUGIN_CACHED_RESOURCE_FILES}
     META ${_PLUGIN_META_FILES}
     MOC ${MY_MOC_CPP}
     GEN_UI ${MY_UI_CPP}
     GEN_QRC ${MY_QRC_SRCS}
   )
 
 
   #------------------------------------------------------------#
   #------------------ Installer support -----------------------#
   if(NOT _PLUGIN_NO_INSTALL)
     set(install_directories "")
     if(NOT MACOSX_BUNDLE_NAMES)
       set(install_directories bin/plugins)
     else(NOT MACOSX_BUNDLE_NAMES)
       foreach(bundle_name ${MACOSX_BUNDLE_NAMES})
         list(APPEND install_directories ${bundle_name}.app/Contents/MacOS/plugins)
       endforeach(bundle_name)
     endif(NOT MACOSX_BUNDLE_NAMES)
 
     foreach(install_subdir ${install_directories})
 
       MACRO_INSTALL_CTK_PLUGIN(TARGETS ${PLUGIN_TARGET}
                                DESTINATION ${install_subdir})
 
     endforeach()
   endif()
 
 endmacro()
 
diff --git a/CMake/mitkMacroCreateCTKPlugin.cmake b/CMake/mitkMacroCreateCTKPlugin.cmake
index 068ca7b78a..0d30001f76 100644
--- a/CMake/mitkMacroCreateCTKPlugin.cmake
+++ b/CMake/mitkMacroCreateCTKPlugin.cmake
@@ -1,76 +1,77 @@
 macro(MACRO_CREATE_MITK_CTK_PLUGIN)
 
   MACRO_PARSE_ARGUMENTS(_PLUGIN "EXPORT_DIRECTIVE;EXPORTED_INCLUDE_SUFFIXES;MODULE_DEPENDENCIES;SUBPROJECTS" "TEST_PLUGIN;NO_INSTALL" ${ARGN})
 
   MITK_CHECK_MODULE(_MODULE_CHECK_RESULT Mitk ${_PLUGIN_MODULE_DEPENDENCIES})
   if(NOT _MODULE_CHECK_RESULT)
     MITK_USE_MODULE(Mitk ${_PLUGIN_MODULE_DEPENDENCIES})
 
     link_directories(${ALL_LIBRARY_DIRS})
     include_directories(${ALL_INCLUDE_DIRECTORIES})
 
     if(_PLUGIN_TEST_PLUGIN)
       set(is_test_plugin "TEST_PLUGIN")
       set(_PLUGIN_NO_INSTALL 1)
     else()
       set(is_test_plugin)
     endif()
 
     if(_PLUGIN_NO_INSTALL)
       set(plugin_no_install "NO_INSTALL")
     else()
       set(plugin_no_install)
     endif()
 
     MACRO_CREATE_CTK_PLUGIN(EXPORT_DIRECTIVE ${_PLUGIN_EXPORT_DIRECTIVE}
                             EXPORTED_INCLUDE_SUFFIXES ${_PLUGIN_EXPORTED_INCLUDE_SUFFIXES}
                             DOXYGEN_TAGFILES ${_PLUGIN_DOXYGEN_TAGFILES}
+                            MOC_OPTIONS -DBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED
                             ${is_test_plugin} ${plugin_no_install})
 
     target_link_libraries(${PLUGIN_TARGET} ${ALL_LIBRARIES})
 
     if(ALL_META_DEPENDENCIES)
       add_dependencies(${PLUGIN_TARGET} ${ALL_META_DEPENDENCIES})
     endif()
 
     if(MITK_DEFAULT_SUBPROJECTS AND NOT MY_SUBPROJECTS)
       set(MY_SUBPROJECTS ${MITK_DEFAULT_SUBPROJECTS})
     endif()
 
     if(MY_SUBPROJECTS)
       set_property(TARGET ${PLUGIN_TARGET} PROPERTY LABELS ${MY_SUBPROJECTS})
       foreach(subproject ${MY_SUBPROJECTS})
         add_dependencies(${subproject} ${PLUGIN_TARGET})
       endforeach()
     endif()
 
     #------------------------------------------------------------#
     #------------------ Installer support -----------------------#
     if(NOT _PLUGIN_NO_INSTALL)
 
       set(_autoload_targets )
       foreach(_dependency ${ALL_DEPENDENCIES})
         get_target_property(_dep_autoloads ${_dependency} MITK_AUTOLOAD_TARGETS)
         if (_dep_autoloads)
           list(APPEND _autoload_targets ${_dep_autoloads})
         endif()
       endforeach()
 
       # The MITK_AUTOLOAD_TARGETS property is used in the mitkFunctionInstallAutoLoadModules
       # macro which expects a list of plug-in targets.
       if (_autoload_targets)
         list(REMOVE_DUPLICATES _autoload_targets)
         set_target_properties(${PLUGIN_TARGET} PROPERTIES MITK_AUTOLOAD_TARGETS "${_autoload_targets}")
       endif()
 
     endif()
 
   else(NOT _MODULE_CHECK_RESULT)
     if(NOT MITK_BUILD_ALL_PLUGINS)
       message(SEND_ERROR "${PROJECT_NAME} is missing requirements and won't be built. Missing: ${_MODULE_CHECK_RESULT}")
     else()
       message(STATUS "${PROJECT_NAME} is missing requirements and won't be built. Missing: ${_MODULE_CHECK_RESULT}")
     endif()
   endif(NOT _MODULE_CHECK_RESULT)
 endmacro()
 
diff --git a/CMakeExternals/CTK.cmake b/CMakeExternals/CTK.cmake
index 7ecb648609..a69679449d 100644
--- a/CMakeExternals/CTK.cmake
+++ b/CMakeExternals/CTK.cmake
@@ -1,93 +1,93 @@
 #-----------------------------------------------------------------------------
 # CTK
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_CTK)
 
   # Sanity checks
   if(DEFINED CTK_DIR AND NOT EXISTS ${CTK_DIR})
     message(FATAL_ERROR "CTK_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj CTK)
   set(proj_DEPENDENCIES )
   set(CTK_DEPENDS ${proj})
 
   if(NOT DEFINED CTK_DIR)
 
-    set(revision_tag 71c756a3)
+    set(revision_tag f18114d2)
     #IF(${proj}_REVISION_TAG)
     #  SET(revision_tag ${${proj}_REVISION_TAG})
     #ENDIF()
 
     set(ctk_optional_cache_args )
     if(MITK_USE_Python)
       list(APPEND ctk_optional_cache_args
            -DCTK_LIB_Scripting/Python/Widgets:BOOL=ON
            -DCTK_ENABLE_Python_Wrapping:BOOL=ON
            -DCTK_APP_ctkSimplePythonShell:BOOL=ON
            -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
            -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
            -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
            -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
       )
     else()
       list(APPEND ctk_optional_cache_args
            -DCTK_LIB_Scripting/Python/Widgets:BOOL=OFF
            -DCTK_ENABLE_Python_Wrapping:BOOL=OFF
            -DCTK_APP_ctkSimplePythonShell:BOOL=OFF
       )
     endif()
 
     if(MITK_USE_DCMTK)
       list(APPEND ctk_optional_cache_args
            -DDCMTK_DIR:PATH=${DCMTK_DIR}
           )
       list(APPEND proj_DEPENDENCIES DCMTK)
     else()
       list(APPEND ctk_optional_cache_args
            -DDCMTK_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_DCMTK_085525e6.tar.gz
           )
     endif()
 
     FOREACH(type RUNTIME ARCHIVE LIBRARY)
       IF(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY)
         LIST(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY})
       ENDIF()
     ENDFOREACH()
 
     ExternalProject_Add(${proj}
       SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
       BINARY_DIR ${proj}-build
       PREFIX ${proj}-cmake
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_${revision_tag}.tar.gz
       URL_MD5 25c219f2d881119312b8cd699b385259
       UPDATE_COMMAND ""
       INSTALL_COMMAND ""
       CMAKE_GENERATOR ${gen}
       CMAKE_ARGS
         ${ep_common_args}
         ${ctk_optional_cache_args}
         -DDESIRED_QT_VERSION:STRING=4
         -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
         -DGit_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}
         -DGIT_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}
         -DCTK_LIB_CommandLineModules/Backend/LocalProcess:BOOL=ON
         -DCTK_LIB_CommandLineModules/Frontend/QtGui:BOOL=ON
         -DCTK_LIB_PluginFramework:BOOL=ON
         -DCTK_LIB_DICOM/Widgets:BOOL=ON
         -DCTK_PLUGIN_org.commontk.eventadmin:BOOL=ON
         -DCTK_PLUGIN_org.commontk.configadmin:BOOL=ON
         -DCTK_USE_GIT_PROTOCOL:BOOL=OFF
         -DDCMTK_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_DCMTK_085525e6.tar.gz
       DEPENDS ${proj_DEPENDENCIES}
      )
   set(CTK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
 endif()
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsBetweennessHistogram.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsBetweennessHistogram.cpp
index 968ca43698..31f1e3ead5 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsBetweennessHistogram.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsBetweennessHistogram.cpp
@@ -1,132 +1,130 @@
 
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include<mitkConnectomicsBetweennessHistogram.h>
 
-#ifndef Q_MOC_RUN
-#  include <boost/numeric/conversion/converter.hpp>
-#endif
+#include <boost/numeric/conversion/converter.hpp>
 
 #include <mitkConnectomicsConstantsManager.h>
 
 mitk::ConnectomicsBetweennessHistogram::ConnectomicsBetweennessHistogram()
 : m_Mode( UnweightedUndirectedMode )
 , m_CentralityMap()
 {
   m_Subject = "Node Betweenness";
 }
 
 mitk::ConnectomicsBetweennessHistogram::~ConnectomicsBetweennessHistogram()
 {
 }
 
 void mitk::ConnectomicsBetweennessHistogram::SetBetweennessCalculationMode(
   const mitk::ConnectomicsBetweennessHistogram::BetweennessCalculationMode & mode )
 {
   m_Mode = mode;
 }
 
 mitk::ConnectomicsBetweennessHistogram::BetweennessCalculationMode mitk::ConnectomicsBetweennessHistogram::GetBetweennessCalculationMode()
 {
   return m_Mode;
 }
 
 void mitk::ConnectomicsBetweennessHistogram::ComputeFromConnectomicsNetwork( ConnectomicsNetwork* source )
 {
   NetworkType* boostGraph = source->GetBoostGraph();
   IteratorType vertex_iterator_begin, vertex_iterator_end;
 
   m_CentralityMap.clear();
   m_CentralityMap.resize( source->GetNumberOfVertices() );
 
   switch( m_Mode )
   {
   case UnweightedUndirectedMode:
     {
       CalculateUnweightedUndirectedBetweennessCentrality( boostGraph, vertex_iterator_begin, vertex_iterator_end );
       break;
     }
   case WeightedUndirectedMode:
     {
       CalculateWeightedUndirectedBetweennessCentrality( boostGraph, vertex_iterator_begin, vertex_iterator_end );
       break;
     }
   }
 
   ConvertCentralityMapToHistogram();
 }
 
 void mitk::ConnectomicsBetweennessHistogram::CalculateUnweightedUndirectedBetweennessCentrality(
   NetworkType* boostGraph, IteratorType vertex_iterator_begin, IteratorType vertex_iterator_end )
 {
   boost::brandes_betweenness_centrality(
     *boostGraph,
     boost::centrality_map(
     boost::make_iterator_property_map( m_CentralityMap.begin(), boost::get( &mitk::ConnectomicsNetwork::NetworkNode::id, *boostGraph ), double() )
     ).vertex_index_map( boost::get( &mitk::ConnectomicsNetwork::NetworkNode::id, *boostGraph ) )
     );
 
 }
 
 void mitk::ConnectomicsBetweennessHistogram::CalculateWeightedUndirectedBetweennessCentrality(
   NetworkType* boostGraph, IteratorType vertex_iterator_begin, IteratorType vertex_iterator_end )
 {
   MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_UNIMPLEMENTED_FEATURE;
 }
 
 void mitk::ConnectomicsBetweennessHistogram::ConvertCentralityMapToHistogram()
 {
   double maximumFloat( 0.0 );
 
   for ( int index( 0 ); index < m_CentralityMap.size(); index++ )
   {
     if( m_CentralityMap[ index ] > maximumFloat )
     {
       maximumFloat = m_CentralityMap[ index ];
     }
    }
 
   // use the boost double to int converter
   // it defaults to trunc
   typedef boost::numeric::converter<int,double> Double2Int ;
 
   // for rounding, reduces the number of nodes classed as zero
   maximumFloat += 0.5;
 
   int maximumInt( 0 );
   try
   {
     maximumInt = Double2Int::convert( maximumFloat );
   }
   catch ( boost::numeric::positive_overflow const& )
   {
     MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_OUTSIDE_INTEGER_RANGE;
   }
 
   m_HistogramVector.resize( maximumInt + 1 );
 
   for ( int index( 0 ); index < m_CentralityMap.size(); index++ )
   {
     int value( 0 );
     value = Double2Int::convert( ( m_CentralityMap[index ] + 0.5 ) );
     m_HistogramVector[ value ]++;
   }
 
   UpdateYMax();
 
   m_Valid = true;
 }
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsBetweennessHistogram.h b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsBetweennessHistogram.h
index e1dfe16cac..80dda02313 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsBetweennessHistogram.h
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsBetweennessHistogram.h
@@ -1,82 +1,80 @@
 
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef _MITK_ConnectomicsBetweennessHistogram_H
 #define _MITK_ConnectomicsBetweennessHistogram_H
 
 #include<mitkConnectomicsHistogramBase.h>
 
-#ifndef Q_MOC_RUN
-#  include <boost/graph/betweenness_centrality.hpp>
-#endif
+#include <boost/graph/betweenness_centrality.hpp>
 
 namespace mitk {
 
     /**
   * \brief A class to calculate and store the betweenness of each node   */
   class ConnectomicsBetweennessHistogram : public mitk::ConnectomicsHistogramBase
   {
 
   public:
 
     /** Enum for different ways to calculate betweenness centrality */
 
     enum BetweennessCalculationMode
     {
       UnweightedUndirectedMode,
       WeightedUndirectedMode
     };
 
     ConnectomicsBetweennessHistogram();
     virtual ~ConnectomicsBetweennessHistogram();
 
     /** Set the calucaltion mode */
     void SetBetweennessCalculationMode( const BetweennessCalculationMode & );
 
     /** Get the calculation mode */
     BetweennessCalculationMode GetBetweennessCalculationMode();
 
   protected:
 
     /* Typedefs */
     typedef mitk::ConnectomicsNetwork::NetworkType NetworkType;
     typedef boost::graph_traits< NetworkType >::vertex_iterator IteratorType;
     typedef std::vector< double > BCMapType;
 
     /** @brief Creates a new histogram from the network source. */
     virtual void ComputeFromConnectomicsNetwork( ConnectomicsNetwork* source );
 
     /** Calculate betweenness centrality ignoring the weight of the edges */
     void CalculateUnweightedUndirectedBetweennessCentrality( NetworkType*, IteratorType, IteratorType );
 
     /** Calculate betweenness centrality taking into consideration the weight of the edges */
     void CalculateWeightedUndirectedBetweennessCentrality( NetworkType*, IteratorType, IteratorType );
 
     /** Converts the centrality map to a histogram by binning */
     void ConvertCentralityMapToHistogram();
 
     /** Stores which mode has been selected for betweenness centrality calculation */
     BetweennessCalculationMode m_Mode;
 
     /** Stores the betweenness centralities for each node */
     BCMapType m_CentralityMap;
   };
 
 }
 
 #endif /* _MITK_ConnectomicsBetweennessHistogram_H */
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsHistogramBase.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsHistogramBase.cpp
index a9c7b290b5..fdc160e587 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsHistogramBase.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsHistogramBase.cpp
@@ -1,228 +1,226 @@
 
 
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkConnectomicsHistogramBase.h>
 #include <mitkConnectomicsConstantsManager.h>
 
-#ifndef Q_MOC_RUN
-#  include <boost/numeric/conversion/converter.hpp>
-#endif
+#include <boost/numeric/conversion/converter.hpp>
 
 mitk::ConnectomicsHistogramBase::ConnectomicsHistogramBase()
 : m_Valid( false )
 , m_BaselineValue( 0 )
 , m_TopValue( 1 )
 , m_StartValue( 0 )
 , m_Subject( "" )
 {
 }
 
 mitk::ConnectomicsHistogramBase::~ConnectomicsHistogramBase()
 {
 }
 
 
 double mitk::ConnectomicsHistogramBase::GetYMin() const
 {
   return m_BaselineValue;
 }
 
 double mitk::ConnectomicsHistogramBase::GetYMax() const
 {
   return m_TopValue;
 }
 
 double mitk::ConnectomicsHistogramBase::GetMin() const
 {
   return this->GetXMin();
 }
 
 double mitk::ConnectomicsHistogramBase::GetMax() const
 {
   return this->GetXMax();
 }
 
 double mitk::ConnectomicsHistogramBase::GetXMin() const
 {
   return m_StartValue;
 }
 
 double mitk::ConnectomicsHistogramBase::GetXMax() const
 {
   return ( m_StartValue + this->GetRange() );
 }
 
 int mitk::ConnectomicsHistogramBase::GetRange() const
 {
   return m_HistogramVector.size();
 }
 
 bool mitk::ConnectomicsHistogramBase::IsValid() const
 {
   return m_Valid;
 }
 
 void mitk::ConnectomicsHistogramBase::PrintToConsole() const
 {
   MITK_INFO << "Histogram - Maximum " << this->GetYMax() << " Minimum " << this->GetYMin() << " Range " << this->GetRange();
 
   for( int index( 0 ); index < m_HistogramVector.size(); index++ )
   {
     MITK_INFO << " Bin: " << index << " Value: " << m_HistogramVector[ index ];
   }
 }
 
 std::string mitk::ConnectomicsHistogramBase::GetSubject() const
 {
   return m_Subject;
 }
 
 void mitk::ConnectomicsHistogramBase::SetSubject( std::string subject )
 {
   m_Subject = subject;
 }
 
 void mitk::ConnectomicsHistogramBase::ComputeFromBaseData( BaseData* source )
 {
   m_Valid = false;
   m_HistogramVector.clear();
 
   //check if input is valid
   if (source==NULL)
   { // empty base data
     return;
   }
 
   mitk::ConnectomicsNetwork* networkSource = dynamic_cast<mitk::ConnectomicsNetwork*>(source);
 
   if (networkSource==NULL)
   { // base data but no network
     return;
   }
 
   ComputeFromConnectomicsNetwork( networkSource );
 }
 
 float mitk::ConnectomicsHistogramBase::GetRelativeBin( double start, double end ) const
 {
   // use the boost double to int converter
   // it defaults to trunc
   typedef boost::numeric::converter<int,double> Double2Int ;
 
   float result( 0.0 );
 
   if( !m_Valid )
   {
     MITK_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_TRIED_TO_ACCESS_INVALID_HISTOGRAM;
     return result;
   }
 
   if( ( start < 0.0 ) ||
       ( end   < 0.0 )   )
   {
     MITK_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_PASSED_NEGATIVE_INDEX_TO_HISTOGRAM;
     return result;
   }
 
   // calculate result
   if( std::abs( end - start ) <= 1.0 )
   { // if the bin size is one or less, we can do not need to interpolate
 
     int index( 0 );
     try
     {
       // show the value for n between n - .5 and n + .5
         double temp = ( start + end ) / 2.0;
         index = Double2Int::convert( temp ); // By default throws positive_overflow()
     }
     catch ( boost::numeric::positive_overflow const& )
     {
       MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_OUTSIDE_INTEGER_RANGE;
     }
 
     if( index < m_HistogramVector.size() )
     {
       result = m_HistogramVector[ index ];
     }
     else
     {
       MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_BEYOND_SCOPE <<
         index << " on vector sized: " <<  m_HistogramVector.size();
     }
   }
   else
   { // if the bin size is more than one we need to interpolate
 
     int indexStart( 0 ), indexEnd( 0 );
 
     try
     {
       indexStart = Double2Int::convert( start );
       indexEnd   = Double2Int::convert( end   );
     }
     catch ( boost::numeric::positive_overflow const& )
     {
       MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_OUTSIDE_INTEGER_RANGE;
     }
 
     if( ( indexStart < m_HistogramVector.size() ) &&
         ( indexEnd   < m_HistogramVector.size() )    )
     {
       // add up weighted values and divide by range
 
       // add partial start and end bin
 
       double startPercentage = 1.0 - start + indexStart;
       double endPercentage   = end - indexEnd;
 
       result += startPercentage * m_HistogramVector[ indexStart ];
       result += endPercentage   * m_HistogramVector[ indexEnd   ];
 
       // add whole inbetween bins
       for( int tempIndex = indexStart + 1; tempIndex < indexEnd; tempIndex++ )
       {
         result += m_HistogramVector[ tempIndex ];
       }
     }
     else
     {
       MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_BEYOND_SCOPE << indexStart << " to " <<
         indexEnd << " on vector sized: " <<  m_HistogramVector.size();
     }
   }
 
   // normalizeresult by dividing through maximum degree
   result = result / GetYMax();
   return result;
 }
 
 void mitk::ConnectomicsHistogramBase::UpdateYMax()
 {
   for ( int index( 0 ); index < m_HistogramVector.size(); index++ )
   {
     if( m_HistogramVector[ index ] > m_TopValue )
     {
       m_TopValue = m_HistogramVector[ index ];
     }
   }
 }
 
 std::vector< double > mitk::ConnectomicsHistogramBase::GetHistogramVector()
 {
   return m_HistogramVector;
 }
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsShortestPathHistogram.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsShortestPathHistogram.cpp
index 8a8cf849e4..0e4e3d0d14 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsShortestPathHistogram.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsShortestPathHistogram.cpp
@@ -1,186 +1,184 @@
 
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include<mitkConnectomicsShortestPathHistogram.h>
 
-#ifndef Q_MOC_RUN
-#  include <boost/graph/dijkstra_shortest_paths.hpp>
-#endif
+#include <boost/graph/dijkstra_shortest_paths.hpp>
 
 #include "mitkConnectomicsConstantsManager.h"
 
 mitk::ConnectomicsShortestPathHistogram::ConnectomicsShortestPathHistogram()
 : m_Mode( UnweightedUndirectedMode )
 , m_EverythingConnected( true )
 {
   m_Subject = "Shortest path";
 }
 
 mitk::ConnectomicsShortestPathHistogram::~ConnectomicsShortestPathHistogram()
 {
 }
 
 void mitk::ConnectomicsShortestPathHistogram::SetShortestPathCalculationMode( const mitk::ConnectomicsShortestPathHistogram::ShortestPathCalculationMode & mode)
 {
   m_Mode = mode;
 }
 
 mitk::ConnectomicsShortestPathHistogram::ShortestPathCalculationMode mitk::ConnectomicsShortestPathHistogram::GetShortestPathCalculationMode()
 {
   return m_Mode;
 }
 
 void mitk::ConnectomicsShortestPathHistogram::ComputeFromConnectomicsNetwork( ConnectomicsNetwork* source )
 {
 
   NetworkType* boostGraph = source->GetBoostGraph();
 
   switch( m_Mode )
   {
   case UnweightedUndirectedMode:
     {
       CalculateUnweightedUndirectedShortestPaths( boostGraph );
       break;
     }
   case WeightedUndirectedMode:
     {
       CalculateWeightedUndirectedShortestPaths( boostGraph );
       break;
     }
   }
 
     ConvertDistanceMapToHistogram();
 }
 
 void mitk::ConnectomicsShortestPathHistogram::CalculateUnweightedUndirectedShortestPaths( NetworkType* boostGraph )
 {
   std::vector< DescriptorType > predecessorMap( boost::num_vertices( *boostGraph ) );
   int numberOfNodes( boost::num_vertices( *boostGraph ) );
 
   m_DistanceMatrix.resize( numberOfNodes );
   for( int index(0); index < m_DistanceMatrix.size(); index++ )
   {
     m_DistanceMatrix[ index ].resize( numberOfNodes );
   }
 
   IteratorType iterator, end;
   boost::tie(iterator, end) = boost::vertices( *boostGraph );
 
   for ( int index(0) ; iterator != end; ++iterator, index++)
   {
           boost::dijkstra_shortest_paths(*boostGraph, *iterator, boost::predecessor_map(&predecessorMap[ 0 ]).distance_map(&m_DistanceMatrix[ index ][ 0 ]).weight_map( boost::get( &mitk::ConnectomicsNetwork::NetworkEdge::edge_weight ,*boostGraph ) ) ) ;
   }
 }
 
 void mitk::ConnectomicsShortestPathHistogram::CalculateWeightedUndirectedShortestPaths( NetworkType* boostGraph )
 {
   MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_UNIMPLEMENTED_FEATURE;
 }
 
 void mitk::ConnectomicsShortestPathHistogram::ConvertDistanceMapToHistogram()
 {
   // get the longest path between any two nodes in the network
   // we assume that no nodes are farther apart than there are nodes,
   // this is to filter unconnected nodes
   int longestPath( 0 );
   int numberOfNodes( m_DistanceMatrix.size() );
   m_EverythingConnected = true;
 
   for( int index(0); index < m_DistanceMatrix.size(); index++ )
   {
     for( int innerIndex(0); innerIndex < m_DistanceMatrix[ index ].size(); innerIndex++ )
     {
       if( m_DistanceMatrix[ index ][ innerIndex ] > longestPath )
       {
         if( m_DistanceMatrix[ index ][ innerIndex ] < numberOfNodes )
         {
           longestPath = m_DistanceMatrix[ index ][ innerIndex ];
         }
         else
         {
           // these nodes are not connected
           m_EverythingConnected = false;
         }
       }
     }
   }
 
   m_HistogramVector.resize( longestPath + 1 );
 
   for( int index(0); index < m_DistanceMatrix.size(); index++ )
   {
     for( int innerIndex(0); innerIndex < m_DistanceMatrix[ index ].size(); innerIndex++ )
     {
       if( m_DistanceMatrix[ index ][ innerIndex ] < numberOfNodes )
       {
         m_HistogramVector[ m_DistanceMatrix[ index ][ innerIndex ] ]++;
       }
     }
   }
 
   // correct for every path being counted twice
 
   for( int index(1); index < m_HistogramVector.size(); index++ )
   {
     m_HistogramVector[ index ] = m_HistogramVector[ index ] / 2;
   }
 
     // correct for every node being distance zero to itself
   if( m_HistogramVector[ 0 ] >= numberOfNodes )
   {
     m_HistogramVector[ 0 ] = m_HistogramVector[ 0 ] - numberOfNodes;
   }
   else
   {
     MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ZERO_DISTANCE_NODES;
   }
 
   UpdateYMax();
 
   this->m_Valid = true;
 }
 
 double mitk::ConnectomicsShortestPathHistogram::GetEfficiency()
 {
   if( !this->m_Valid )
   {
     MBI_INFO << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_CAN_NOT_COMPUTE_EFFICIENCY << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_NETWORK_NOT_VALID;
     return 0.0;
   }
 
   if( !m_EverythingConnected )
   { // efficiency of disconnected graphs is 0
         MBI_INFO << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_NETWORK_DISCONNECTED;
     return 0.0;
   }
 
   double efficiency( 0.0 );
 
   double overallDistance( 0.0 );
   double numberOfPairs( 0.0 );
   // add up all distances
   for( int index(0); index < m_HistogramVector.size(); index++ )
   {
     overallDistance = overallDistance + m_HistogramVector[ index ] * index;
     numberOfPairs = numberOfPairs + m_HistogramVector[ index ];
   }
 
   // efficiency = 1 / averageDistance = 1 / ( overallDistance / numberofPairs )
   efficiency = numberOfPairs / overallDistance;
 
   return efficiency;
 }
diff --git a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
index 350a0168d7..8157651ebb 100644
--- a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
+++ b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.cpp
@@ -1,700 +1,698 @@
 
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkConnectomicsNetwork.h"
-#ifndef Q_MOC_RUN
-#  include <boost/graph/clustering_coefficient.hpp>
-#  include <boost/graph/betweenness_centrality.hpp>
-#endif
+#include <boost/graph/clustering_coefficient.hpp>
+#include <boost/graph/betweenness_centrality.hpp>
 
 /* Constructor and Destructor */
 mitk::ConnectomicsNetwork::ConnectomicsNetwork()
 : m_IsModified( false )
 {
 }
 
 mitk::ConnectomicsNetwork::~ConnectomicsNetwork()
 {
 }
 
 /* Wrapper methods */
 
 bool mitk::ConnectomicsNetwork::EdgeExists(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB ) const
 {
   return boost::edge(vertexA, vertexB, m_Network ).second;
 }
 
 void mitk::ConnectomicsNetwork::IncreaseEdgeWeight(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertexA, mitk::ConnectomicsNetwork::VertexDescriptorType vertexB )
 {
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight++;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::AddEdge(
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexA,
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexB
                                         )
 {
   AddEdge(vertexA, vertexB, m_Network[ vertexA ].id, m_Network[ vertexB ].id );
 }
 
 void mitk::ConnectomicsNetwork::AddEdge(
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexA,
                                         mitk::ConnectomicsNetwork::VertexDescriptorType vertexB,
                                         int sourceID, int targetID, int weight )
 {
   boost::add_edge( vertexA, vertexB, m_Network );
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].sourceId = sourceID;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].targetId = targetID;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].weight = weight;
   m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ].edge_weight = 1.0;
 
   SetIsModified( true );
 }
 
 mitk::ConnectomicsNetwork::VertexDescriptorType mitk::ConnectomicsNetwork::AddVertex( int id )
 {
   VertexDescriptorType vertex = boost::add_vertex( m_Network );
   m_Network[vertex].id = id;
 
   SetIsModified( true );
 
   return vertex;
 }
 
 void mitk::ConnectomicsNetwork::SetLabel(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::string inLabel )
 {
   m_Network[vertex].label = inLabel;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::SetCoordinates(
   mitk::ConnectomicsNetwork::VertexDescriptorType vertex, std::vector< float > inCoordinates )
 {
   m_Network[vertex].coordinates = inCoordinates;
 
   SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::clear()
 {
   m_Network.clear();
 
   SetIsModified( true );
 }
 
 /* Superclass methods, that need to be implemented */
 void mitk::ConnectomicsNetwork::UpdateOutputInformation()
 {
 
 }
 void mitk::ConnectomicsNetwork::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 bool mitk::ConnectomicsNetwork::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 bool mitk::ConnectomicsNetwork::VerifyRequestedRegion()
 {
   return true;
 }
 void mitk::ConnectomicsNetwork::SetRequestedRegion(const itk::DataObject *data )
 {
 
 }
 
 
 
 std::vector< mitk::ConnectomicsNetwork::NetworkNode >
 mitk::ConnectomicsNetwork::GetVectorOfAllNodes() const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   std::vector< NetworkNode > vectorOfNodes;
 
   for ( ; iterator != end; ++iterator)
   {
     NetworkNode tempNode;
 
     // the value of an iterator is a descriptor
     tempNode = m_Network[ *iterator ];
 
     vectorOfNodes.push_back( tempNode );
   }
 
   return vectorOfNodes;
 }
 
 std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType >
 mitk::ConnectomicsNetwork::GetVectorOfAllVertexDescriptors() const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   std::vector< VertexDescriptorType > vectorOfDescriptors;
 
   for ( ; iterator != end; ++iterator)
   {
     vectorOfDescriptors.push_back( *iterator );
   }
 
   return vectorOfDescriptors;
 }
 
 std::vector< std::pair<
 std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode >
 , mitk::ConnectomicsNetwork::NetworkEdge > >
 mitk::ConnectomicsNetwork::GetVectorOfAllEdges() const
 {
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::edges( m_Network );
 
   std::vector<
     std::pair<
     std::pair< NetworkNode, NetworkNode >
     , NetworkEdge
     >
   > vectorOfEdges;
 
   for ( ; iterator != end; ++iterator)
   {
     NetworkNode sourceNode, targetNode;
     NetworkEdge tempEdge;
 
     // the value of an iterator is a descriptor
     tempEdge = m_Network[ *iterator ];
     sourceNode = m_Network[ boost::source( *iterator, m_Network ) ];
     targetNode = m_Network[ boost::target( *iterator, m_Network ) ];
 
     std::pair< NetworkNode, NetworkNode > nodePair( sourceNode, targetNode );
     std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > edgePair( nodePair, tempEdge);
     vectorOfEdges.push_back( edgePair );
   }
 
   return vectorOfEdges;
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfVertices() const
 {
   return boost::num_vertices( m_Network );
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfEdges() const
 {
   return boost::num_edges( m_Network );
 }
 
 int mitk::ConnectomicsNetwork::GetMaximumWeight() const
 {
   int maxWeight( 0 );
 
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::edges( m_Network );
 
   for ( ; iterator != end; ++iterator)
   {
     int tempWeight;
 
     // the value of an iterator is a descriptor
     tempWeight = m_Network[ *iterator ].weight;
 
     if( tempWeight > maxWeight )
     {
       maxWeight = tempWeight;
     }
   }
 
   return maxWeight;
 }
 
 int mitk::ConnectomicsNetwork::GetNumberOfSelfLoops()
 {
   int noOfSelfLoops( 0 );
 
   std::vector< std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > >
     edgeVector =  GetVectorOfAllEdges();
 
   for( int index = 0; index < edgeVector.size() ; index++ )
   {
     double sourceX, sourceY, sourceZ, targetX, targetY, targetZ;
 
     sourceX = edgeVector[ index ].first.first.coordinates[0] ;
     sourceY = edgeVector[ index ].first.first.coordinates[1] ;
     sourceZ = edgeVector[ index ].first.first.coordinates[2] ;
     targetX = edgeVector[ index ].first.second.coordinates[0] ;
     targetY = edgeVector[ index ].first.second.coordinates[1] ;
     targetZ = edgeVector[ index ].first.second.coordinates[2] ;
 
     // if the coordinates are the same
     if(
       sourceX > ( targetX - 0.01 ) &&
       sourceX < ( targetX + 0.01 ) &&
       sourceY > ( targetY - 0.01 ) &&
       sourceY < ( targetY + 0.01 ) &&
       sourceZ > ( targetZ - 0.01 ) &&
       sourceZ < ( targetZ + 0.01 )
       )
     {
       noOfSelfLoops++;
     }
   }
 
   return noOfSelfLoops;
 }
 
 double mitk::ConnectomicsNetwork::GetAverageDegree()
 {
   double vertices = (double) GetNumberOfVertices();
   double edges = (double) GetNumberOfEdges();
 
   return ( ( edges * 2.0 ) / vertices );
 }
 
 double mitk::ConnectomicsNetwork::GetConnectionDensity()
 {
   double vertices = (double) GetNumberOfVertices();
   double edges = (double) GetNumberOfEdges();
   double numberOfPossibleEdges = vertices * ( vertices - 1 ) / 2 ;
 
   return ( edges / numberOfPossibleEdges );
 }
 
 std::vector< int > mitk::ConnectomicsNetwork::GetDegreeOfNodes( ) const
 {
   std::vector< int > vectorOfDegree;
 
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie( iterator, end ) = boost::vertices( m_Network );
 
   vectorOfDegree.resize( this->GetNumberOfVertices() );
 
   for ( ; iterator != end; ++iterator)
   {
     // the value of an iterator is a descriptor
     vectorOfDegree[ m_Network[ *iterator ].id ] = GetVectorOfAdjacentNodes( *iterator ).size();
   }
   return vectorOfDegree;
 }
 
 std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType >
 mitk::ConnectomicsNetwork::GetVectorOfAdjacentNodes( mitk::ConnectomicsNetwork::VertexDescriptorType vertex ) const
 {
   std::vector< mitk::ConnectomicsNetwork::VertexDescriptorType > vectorOfAdjacentNodes;
 
   boost::graph_traits<NetworkType>::adjacency_iterator adjIter, adjEnd;
 
   boost::tie( adjIter, adjEnd ) = boost::adjacent_vertices( vertex, m_Network);
 
   for ( ; adjIter != adjEnd; ++adjIter)
   {
     vectorOfAdjacentNodes.push_back( *adjIter );
   }
 
   return vectorOfAdjacentNodes;
 }
 
 int mitk::ConnectomicsNetwork::GetMaximumDegree() const
 {
   int maximumDegree( 0 );
 
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
 
   for( int index( 0 ); index < vectorOfDegree.size(); ++index )
   {
     if( maximumDegree < vectorOfDegree[ index ] )
     {
       maximumDegree = vectorOfDegree[ index ];
     }
   }
 
   return maximumDegree;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetLocalClusteringCoefficients( ) const
 {
   std::vector< double > vectorOfClusteringCoefficients;
 
   typedef boost::graph_traits<NetworkType>::vertex_iterator vertexIter;
 
   vectorOfClusteringCoefficients.resize( this->GetNumberOfVertices() );
 
   std::pair<vertexIter, vertexIter> vertexPair;
 
   //for every vertex calculate the clustering coefficient
   int size = vectorOfClusteringCoefficients.size();
   for (vertexPair = vertices(m_Network); vertexPair.first != vertexPair.second; ++vertexPair.first)
   {
     int index = m_Network[ *vertexPair.first ].id;
 
     if( index > size )
     {
       MITK_ERROR << "Trying to access out of bounds clustering coefficient";
       continue;
     }
 
     vectorOfClusteringCoefficients[ index ] =
       boost::clustering_coefficient(m_Network,*vertexPair.first) ;
   }
 
   return vectorOfClusteringCoefficients;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetClusteringCoefficientsByDegree( )
 {
   std::vector< double > vectorOfClusteringCoefficients = GetLocalClusteringCoefficients();
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
 
   std::vector< double > vectorOfClusteringCoefficientsByDegree;
   vectorOfClusteringCoefficientsByDegree.resize( GetMaximumDegree() + 1, 0 );
 
   // c_{mean}(k) = frac{1}_{N_{k}} sum_{i in Y(k)} c_{i}
   // where N_{k} is the number of vertices of degree k
   // Y(k) is the set of vertices of degree k
   // c_{i} is the local clustering coefficient of vertex i
   for( int degree( 0 ); degree < vectorOfClusteringCoefficientsByDegree.size(); ++degree )
   {
     vectorOfClusteringCoefficientsByDegree[ degree ] = 0;
     int n_k( 0 );
     for( int index( 0 ); index < vectorOfDegree.size(); ++index )
     {
       if( degree == vectorOfDegree[ index ] )
       {// if in Y( degree )
         vectorOfClusteringCoefficientsByDegree[ degree ] += vectorOfClusteringCoefficients[ index ];
         n_k++;
       }
     }
     if( n_k != 0 )
     {
       vectorOfClusteringCoefficientsByDegree[ degree ] =
         vectorOfClusteringCoefficientsByDegree[ degree ] / n_k;
     }
   }
 
   return vectorOfClusteringCoefficientsByDegree;
 }
 
 double mitk::ConnectomicsNetwork::GetGlobalClusteringCoefficient( )
 {
   double globalClusteringCoefficient( 0.0 );
 
   std::vector< double > vectorOfClusteringCoefficientsByDegree = GetClusteringCoefficientsByDegree();
   std::vector< int > vectorOfDegree = GetDegreeOfNodes();
   std::vector< int > degreeDistribution;
   degreeDistribution.resize( vectorOfClusteringCoefficientsByDegree.size(), 0 );
 
   int normalizationParameter( 0 );
 
   for( int index( 0 ); index < vectorOfDegree.size(); ++index )
   {
     degreeDistribution[ vectorOfDegree[ index ] ]++;
     normalizationParameter++;
   }
   // c_{mean} = sum_{k} P_{k} c_{mean}(k)
   // where P_{k} is the degree distribution
   // k is the degree
   for( int degree( 0 ); degree < degreeDistribution.size(); ++degree )
   {
     globalClusteringCoefficient +=
       degreeDistribution[ degree ] / ( (double) normalizationParameter)
       * vectorOfClusteringCoefficientsByDegree[ degree ];
   }
 
   return globalClusteringCoefficient;
 }
 
 mitk::ConnectomicsNetwork::NetworkType* mitk::ConnectomicsNetwork::GetBoostGraph()
 {
   return &m_Network;
 }
 
 
 bool mitk::ConnectomicsNetwork::GetIsModified() const
 {
   return m_IsModified;
 }
 
 
 void mitk::ConnectomicsNetwork::SetIsModified( bool value)
 {
   m_IsModified = value;
 }
 
 
 mitk::ConnectomicsNetwork::NetworkNode mitk::ConnectomicsNetwork::GetNode( VertexDescriptorType vertex ) const
 {
   return m_Network[ vertex ];
 }
 
 
 mitk::ConnectomicsNetwork::NetworkEdge mitk::ConnectomicsNetwork::GetEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const
 {
   return m_Network[ boost::edge(vertexA, vertexB, m_Network ).first ];
 }
 
 void mitk::ConnectomicsNetwork::UpdateBounds( )
 {
   float min = itk::NumericTraits<float>::min();
   float max = itk::NumericTraits<float>::max();
   float bounds[] = {max, min, max, min, max, min};
 
   std::vector< mitk::ConnectomicsNetwork::NetworkNode > nodeVector = this->GetVectorOfAllNodes();
 
   if( nodeVector.size() == 0 )
   {
     bounds[0] = 0;
     bounds[1] = 1;
     bounds[2] = 0;
     bounds[3] = 1;
     bounds[4] = 0;
     bounds[5] = 1;
   }
 
   // for each direction, make certain the point is in between
   for( int index(0), end(nodeVector.size()) ; index < end; index++ )
   {
     for( int direction(0); direction < nodeVector.at( index ).coordinates.size(); direction++ )
     {
       if( nodeVector.at( index ).coordinates.at(direction) < bounds[ 2 * direction ]  )
       {
         bounds[ 2 * direction ] = nodeVector.at( index ).coordinates.at(direction);
       }
 
       if( nodeVector.at( index ).coordinates.at(direction) > bounds[ 2 * direction + 1]  )
       {
         bounds[ 2 * direction + 1] = nodeVector.at( index ).coordinates.at(direction);
       }
     }
   }
 
 
   // provide some border margin
   for(int i=0; i<=4; i+=2)
   {
     bounds[i] -=10;
   }
 
   for(int i=1; i<=5; i+=2)
   {
     bounds[i] +=10;
   }
 
   this->GetGeometry()->SetFloatBounds(bounds);
   this->GetTimeSlicedGeometry()->UpdateInformation();
 }
 
 void mitk::ConnectomicsNetwork::PruneUnconnectedSingleNodes()
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
 
   // set to true if iterators are invalidated by deleting a vertex
   bool vertexHasBeenRemoved( true );
 
   // if no vertex has been removed in the last loop, we are done
   while( vertexHasBeenRemoved )
   {
     vertexHasBeenRemoved = false;
     // sets iterator to start and end to end
     boost::tie(iterator, end) = boost::vertices( m_Network );
 
     for ( ; iterator != end && !vertexHasBeenRemoved; ++iterator)
     {
       // If the node has no adjacent vertices it should be deleted
       if( GetVectorOfAdjacentNodes( *iterator ).size() == 0 )
       {
         vertexHasBeenRemoved = true;
         // this invalidates all iterators
         boost::remove_vertex( *iterator, m_Network );
       }
     }
   }
 
   UpdateIDs();
 }
 
 void mitk::ConnectomicsNetwork::UpdateIDs()
 {
   boost::graph_traits<NetworkType>::vertex_iterator v_i, v_end;
   boost::graph_traits<NetworkType>::edge_iterator e_i, e_end;
 
   // update node ids
   boost::tie( v_i, v_end ) = boost::vertices( m_Network );
 
   for ( ; v_i != v_end; ++v_i)
   {
     m_Network[*v_i].id = *v_i;
   }
 
   // update edge information
   boost::tie(e_i, e_end) = boost::edges( m_Network );
 
   for ( ; e_i != e_end; ++e_i)
   {
     m_Network[ *e_i ].sourceId = m_Network[ boost::source( *e_i, m_Network ) ].id;
     m_Network[ *e_i ].targetId = m_Network[ boost::target( *e_i, m_Network ) ].id;
   }
   this->SetIsModified( true );
 }
 
 void mitk::ConnectomicsNetwork::PruneEdgesBelowWeight( int targetWeight )
 {
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // set to true if iterators are invalidated by deleting a vertex
   bool edgeHasBeenRemoved( true );
 
   // if no vertex has been removed in the last loop, we are done
   while( edgeHasBeenRemoved )
   {
     edgeHasBeenRemoved = false;
     // sets iterator to start and end to end
     boost::tie(iterator, end) = boost::edges( m_Network );
 
     for ( ; iterator != end && !edgeHasBeenRemoved; ++iterator)
     {
       // If the node has no adjacent edges it should be deleted
       if( m_Network[ *iterator ].weight < targetWeight )
       {
         edgeHasBeenRemoved = true;
         // this invalidates all iterators
         boost::remove_edge( *iterator, m_Network );
       }
     }
   }
 
   // this will remove any nodes which, after deleting edges are now
   // unconnected, also this calls UpdateIDs()
   PruneUnconnectedSingleNodes();
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetNodeBetweennessVector() const
 {
   std::vector< double > betweennessVector;
 
   betweennessVector.clear();
   betweennessVector.resize( this->GetNumberOfVertices() );
 
   boost::brandes_betweenness_centrality(
     m_Network,
     boost::centrality_map(
     boost::make_iterator_property_map( betweennessVector.begin(), boost::get( &NetworkNode::id, m_Network ), double() )
     ).vertex_index_map( boost::get( &NetworkNode::id, m_Network ) )
     );
 
   return betweennessVector;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetEdgeBetweennessVector() const
 {
   // std::map used for convenient initialization
   typedef std::map<EdgeDescriptorType, int> EdgeIndexStdMap;
   EdgeIndexStdMap stdEdgeIndex;
   // associative property map needed for iterator property map-wrapper
   typedef boost::associative_property_map< EdgeIndexStdMap > EdgeIndexMap;
   EdgeIndexMap edgeIndex(stdEdgeIndex);
 
   boost::graph_traits<NetworkType>::edge_iterator iterator, end;
 
   // sets iterator to start end end to end
   boost::tie(iterator, end) = boost::edges( m_Network );
 
   int i(0);
   for ( ; iterator != end; ++iterator, ++i)
   {
     stdEdgeIndex.insert(std::pair< EdgeDescriptorType, int >( *iterator, i));
   }
 
   // Define EdgeCentralityMap
   std::vector< double > edgeBetweennessVector(boost::num_edges( m_Network ), 0.0);
   // Create the external property map
   boost::iterator_property_map< std::vector< double >::iterator, EdgeIndexMap >
     e_centrality_map(edgeBetweennessVector.begin(), edgeIndex);
 
   // Define VertexCentralityMap
   typedef boost::property_map< NetworkType, boost::vertex_index_t>::type VertexIndexMap;
   VertexIndexMap vertexIndex = get(boost::vertex_index, m_Network );
   std::vector< double > betweennessVector(boost::num_vertices( m_Network ), 0.0);
   // Create the external property map
   boost::iterator_property_map< std::vector< double >::iterator, VertexIndexMap >
     v_centrality_map(betweennessVector.begin(), vertexIndex);
 
   boost::brandes_betweenness_centrality( m_Network, v_centrality_map, e_centrality_map );
 
   return edgeBetweennessVector;
 }
 
 std::vector< double > mitk::ConnectomicsNetwork::GetShortestDistanceVectorFromLabel( std::string targetLabel ) const
 {
   std::vector< VertexDescriptorType > predecessorMap( boost::num_vertices( m_Network ) );
   int numberOfNodes( boost::num_vertices( m_Network ) );
 
   std::vector< double > distanceMatrix;
   distanceMatrix.resize( numberOfNodes );
 
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   while( (iterator != end) && (m_Network[ *iterator ].label != targetLabel) )
   {
     ++iterator;
   }
 
   if( iterator == end )
   {
     MITK_WARN << "Label not found";
     return distanceMatrix;
   }
 
   boost::dijkstra_shortest_paths(m_Network, *iterator, boost::predecessor_map(&predecessorMap[ 0 ]).distance_map(&distanceMatrix[ 0 ]).weight_map( boost::get( &NetworkEdge::edge_weight ,m_Network ) ) ) ;
 
   return distanceMatrix;
 }
 
 bool mitk::ConnectomicsNetwork::CheckForLabel( std::string targetLabel ) const
 {
   boost::graph_traits<NetworkType>::vertex_iterator iterator, end;
   boost::tie(iterator, end) = boost::vertices( m_Network );
 
   while( (iterator != end) && (m_Network[ *iterator ].label != targetLabel) )
   {
     ++iterator;
   }
 
   if( iterator == end )
   {
     return false;
   }
 
   return true;
 }
diff --git a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.h b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.h
index a7f2425239..002c5c3fbe 100644
--- a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.h
+++ b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsNetwork.h
@@ -1,229 +1,227 @@
 
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef _MITK_ConnectomicsNetwork_H
 #define _MITK_ConnectomicsNetwork_H
 
 #include "ConnectomicsExports.h"
 
 #include "mitkBaseData.h"
 
-#ifndef Q_MOC_RUN
-#  include <boost/graph/adjacency_list.hpp>
-#endif
+#include <boost/graph/adjacency_list.hpp>
 
 namespace mitk {
 
   /**
   * \brief Connectomics Network Class
   *
   * This class is designed to represent a connectomics network (brain network). It encapsulates a
   * boost adjacency list and provides additional capabilities. The information contained in the nodes and edges is:
   *
   * Network Node:
   * <ul>
   *  <li> int ID - The id of the node
   *  <li> string label - The label of the node, this can be any string, such as an anatomical label
   *  <li> vector<float> coordinates - The coordinates the node should be displayed at
   * </ul>
   *
   * Network Edge:
   * <ul>
   *  <li> int sourceId - The Id of the source node
   *  <li> int targetId - The Id of the target node
   *  <li> int weight - Weight of the edge as int (used for counting fibers)
   *  <li> double edge_weight - Used for boost and algorithms, should be between 0 and 1
   * </ul>
   */
   class Connectomics_EXPORT ConnectomicsNetwork : public BaseData
   {
   public:
     /** Structs for the graph */
 
     /** The Node */
     struct NetworkNode
     {
       int id;
       std::string label;
       std::vector< float > coordinates;
     };
 
     /** The Edge */
     struct NetworkEdge
     {
       int sourceId;
       int targetId;
       int weight; // For now the number of times it was present
       double edge_weight; // For boost, currently set to 1 by default for unweighted calculations
     };
 
     /** Typedefs **/
     //typedef boost::adjacency_list< boost::listS, boost::listS, boost::undirectedS, NetworkNode, NetworkEdge > NetworkType;
     typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::undirectedS, NetworkNode, NetworkEdge > NetworkType;
     typedef boost::graph_traits<NetworkType>::vertex_descriptor VertexDescriptorType;
     typedef boost::graph_traits<NetworkType>::edge_descriptor EdgeDescriptorType;
 
     // virtual methods that need to be implemented
     virtual void UpdateOutputInformation();
     virtual void SetRequestedRegionToLargestPossibleRegion();
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
     virtual bool VerifyRequestedRegion();
     virtual void SetRequestedRegion(const itk::DataObject *data );
 
 
     // Macros
     mitkClassMacro( ConnectomicsNetwork, BaseData );
     itkNewMacro( Self );
 
     ////////////////// Interface ///////////////////
     /** return whether an edge exists between the two given vertices */
     bool EdgeExists( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const;
 
     /** increase the weight of an edge between the two given vertices */
     void IncreaseEdgeWeight( VertexDescriptorType vertexA, VertexDescriptorType vertexB );
 
     /** add an edge between two given vertices */
     void AddEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB);
 
     /** add an edge between two given vertices ( with a specific weight ) */
     void AddEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB, int sourceID, int targetID, int weight = 1 );
 
     /** add a vertex with a specified id */
     VertexDescriptorType AddVertex( int id);
 
     /** set the label of a vertex */
     void SetLabel( VertexDescriptorType vertex, std::string inLabel );
 
     /** set the coordinates of a vertex */
     void SetCoordinates( VertexDescriptorType vertex, std::vector< float > inCoordinates );
 
     /** clear the graph */
     void clear();
 
     /** return the node struct for a given node descriptor */
     NetworkNode GetNode( VertexDescriptorType vertex ) const;
 
     /** return the edge struct for two given node descriptors */
     NetworkEdge GetEdge( VertexDescriptorType vertexA, VertexDescriptorType vertexB ) const;
 
     /** get vector containing all the nodes of the network */
     std::vector< NetworkNode > GetVectorOfAllNodes() const;
 
     /** get vector containing all the vertex descriptors of the network */
     std::vector< VertexDescriptorType > GetVectorOfAllVertexDescriptors() const;
 
     /** get vector containing the descriptors of nodes adjacent to the vertex denoted by the given descriptor  */
     std::vector< VertexDescriptorType > GetVectorOfAdjacentNodes( VertexDescriptorType vertex ) const;
 
     /** get vector containing all the edges of the network and the connected nodes */
     std::vector< std::pair< std::pair< NetworkNode, NetworkNode > , NetworkEdge > > GetVectorOfAllEdges() const;
 
     /** get overall number of vertices in the network */
     int GetNumberOfVertices() const;
 
     /** get overall number of edges in the network */
     int GetNumberOfEdges() const;
 
     /** get number of vertices, that are connected to themselves */
     int GetNumberOfSelfLoops();
 
     /** get number of vertices, that are connected to themselves */
     double GetAverageDegree();
 
     /** get number of edges divided by number of possible edges */
     double GetConnectionDensity();
 
     /** Get the maximum weight of all edges */
     int GetMaximumWeight() const;
 
     /** Get a vector in the format vector[ vertexID ] = degree */
     std::vector< int > GetDegreeOfNodes( ) const;
 
     /** Get the maximum degree of all nodes */
     int GetMaximumDegree() const;
 
     /** Get a vector in the format vector[ vertexID ] = clustering coefficient */
     std::vector< double > GetLocalClusteringCoefficients( ) const;
 
     /** Get a vector in the format vector[ degree ] = average clustering coefficient */
     std::vector< double > GetClusteringCoefficientsByDegree( );
 
     /** Get the global clustering coefficient */
     double GetGlobalClusteringCoefficient( );
 
     /** Get the betweenness centrality for each vertex in form of a vector of length (number vertices)*/
     std::vector< double > GetNodeBetweennessVector() const;
 
     /** Get the betweenness centrality for each edge in form of a vector of length (number edges)*/
     std::vector< double > GetEdgeBetweennessVector() const;
 
     /** Check whether a vertex with the specified label exists*/
     bool CheckForLabel( std::string targetLabel ) const;
 
     /** Get the shortest distance from a specified vertex to all other vertices in form of a vector of length (number vertices)*/
     std::vector< double > GetShortestDistanceVectorFromLabel( std::string targetLabel ) const;
 
     /** Access boost graph directly */
     NetworkType* GetBoostGraph();
 
     /** Get the modified flag */
     bool GetIsModified() const;
 
     /** Set the modified flag */
     void SetIsModified( bool );
 
     /** Update the bounds of the geometry to fit the network */
     void UpdateBounds( );
 
     /** Remove nodes not connected to any other node */
     void PruneUnconnectedSingleNodes();
 
     /** Remove edges below the specified weight
       *
       * targetWeight is the number of connecting fibers
       *
       * This will remove unconnected nodes after removal
       */
     void PruneEdgesBelowWeight( int targetWeight );
 
   protected:
     ConnectomicsNetwork();
     virtual ~ConnectomicsNetwork();
 
     /** This function will relabel all vertices and edges in a continuous manner
       *
       * Mainly important after removing vertices, to make sure that the ids run continuously from
       * 0 to number of vertices - 1 and edge target and source ids match the corresponding node.
       */
     void UpdateIDs();
 
     NetworkType m_Network;
 
     /// Flag which indicates whether the network has been modified since the last check
     ///
     /// mainly for rendering purposes
 
     bool m_IsModified;
 
   private:
 
   };
 
 } // namespace mitk
 
 #endif /*  _MITK_ConnectomicsNetwork_H */
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.cpp
index 8331f7ded6..51918d9bda 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.cpp
@@ -1,804 +1,802 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef __itkAnalyticalDiffusionQballReconstructionImageFilter_cpp
 #define __itkAnalyticalDiffusionQballReconstructionImageFilter_cpp
 
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <itkArray.h>
 #include <vnl/vnl_vector.h>
 
 #include <boost/version.hpp>
 #include <stdio.h>
 #include <locale>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
-#ifndef Q_MOC_RUN
-#  include <boost/math/special_functions.hpp>
-#endif
+#include <boost/math/special_functions.hpp>
 
 #include "itkPointShell.h"
 
 using namespace boost::math;
 
 namespace itk {
 
 #define QBALL_ANAL_RECON_PI       M_PI
 
 template< class T, class TG, class TO, int L, int NODF>
 AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
 ::AnalyticalDiffusionQballReconstructionImageFilter() :
     m_GradientDirectionContainer(NULL),
     m_NumberOfGradientDirections(0),
     m_NumberOfBaselineImages(1),
     m_Threshold(NumericTraits< ReferencePixelType >::NonpositiveMin()),
     m_BValue(1.0),
     m_Lambda(0.0),
     m_DirectionsDuplicated(false),
     m_Delta1(0.001),
     m_Delta2(0.001)
 {
     // At least 1 inputs is necessary for a vector image.
     // For images added one at a time we need at least six
     this->SetNumberOfRequiredInputs( 1 );
 }
 
 
 template<
         class TReferenceImagePixelType,
         class TGradientImagePixelType,
         class TOdfPixelType,
         int NOrderL,
         int NrOdfDirections>
 typename itk::AnalyticalDiffusionQballReconstructionImageFilter<
 TReferenceImagePixelType,TGradientImagePixelType,TOdfPixelType,
 NOrderL,NrOdfDirections>::OdfPixelType
 itk::AnalyticalDiffusionQballReconstructionImageFilter
 <TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType,
 NOrderL, NrOdfDirections>
 ::Normalize( OdfPixelType odf,
              typename NumericTraits<ReferencePixelType>::AccumulateType b0 )
 {
     switch( m_NormalizationMethod )
     {
     case QBAR_STANDARD:
     {
         TOdfPixelType sum = 0;
 
         for(int i=0; i<NrOdfDirections; i++)
         {
             sum += odf[i];
         }
         if(sum>0)
             odf /= sum;
 
         return odf;
         break;
     }
     case QBAR_B_ZERO_B_VALUE:
     {
         for(int i=0; i<NrOdfDirections; i++)
         {
             odf[i] = ((TOdfPixelType)log((TOdfPixelType)b0)-odf[i])/m_BValue;
         }
         return odf;
         break;
     }
     case QBAR_B_ZERO:
     {
         odf *= 1.0/b0;
         return odf;
         break;
     }
     case QBAR_NONE:
     {
         return odf;
         break;
     }
     case QBAR_ADC_ONLY:
     {
         for(int i=0; i<NrOdfDirections; i++)
         {
             odf[i] = ((TOdfPixelType)log((TOdfPixelType)b0)-odf[i])/m_BValue;
         }
         return odf;
         break;
     }
     case QBAR_RAW_SIGNAL:
     {
         return odf;
         break;
     }
     case QBAR_SOLID_ANGLE:
     {
         for(int i=0; i<NrOdfDirections; i++)
             odf[i] *= QBALL_ANAL_RECON_PI*4/NrOdfDirections;
 
         break;
     }
     case QBAR_NONNEG_SOLID_ANGLE:
     {
         break;
     }
     }
 
     return odf;
 }
 
 
 template<
         class TReferenceImagePixelType,
         class TGradientImagePixelType,
         class TOdfPixelType,
         int NOrderL,
         int NrOdfDirections>
 vnl_vector<TOdfPixelType>
 itk::AnalyticalDiffusionQballReconstructionImageFilter
 <TReferenceImagePixelType, TGradientImagePixelType, TOdfPixelType,
 NOrderL, NrOdfDirections>
 ::PreNormalize( vnl_vector<TOdfPixelType> vec,
                 typename NumericTraits<ReferencePixelType>::AccumulateType b0 )
 {
     switch( m_NormalizationMethod )
     {
     case QBAR_STANDARD:
     {
         return vec;
         break;
     }
     case QBAR_B_ZERO_B_VALUE:
     {
         int n = vec.size();
         for(int i=0; i<n; i++)
         {
             if (vec[i]<=0)
                 vec[i] = 0.001;
 
             vec[i] = log(vec[i]);
         }
         return vec;
         break;
     }
     case QBAR_B_ZERO:
     {
         return vec;
         break;
     }
     case QBAR_NONE:
     {
         return vec;
         break;
     }
     case QBAR_ADC_ONLY:
     {
         int n = vec.size();
         for(int i=0; i<n; i++)
         {
             if (vec[i]<=0)
                 vec[i] = 0.001;
 
             vec[i] = log(vec[i]);
         }
         return vec;
         break;
     }
     case QBAR_RAW_SIGNAL:
     {
         return vec;
         break;
     }
     case QBAR_SOLID_ANGLE:
     case QBAR_NONNEG_SOLID_ANGLE:
     {
         int n = vec.size();
         double b0f = (double)b0;
         for(int i=0; i<n; i++)
         {
             vec[i] = vec[i]/b0f;
 
             if (vec[i]<0)
                 vec[i] = m_Delta1;
             else if (vec[i]<m_Delta1)
                 vec[i] = m_Delta1/2 + vec[i]*vec[i]/(2*m_Delta1);
             else if (vec[i]>=1)
                 vec[i] = 1-m_Delta2/2;
             else if (vec[i]>=1-m_Delta2)
                 vec[i] = 1-m_Delta2/2-(1-vec[i])*(1-vec[i])/(2*m_Delta2);
 
             vec[i] = log(-log(vec[i]));
         }
         return vec;
         break;
     }
     }
 
     return vec;
 }
 
 template< class T, class TG, class TO, int L, int NODF>
 void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
 ::BeforeThreadedGenerateData()
 {
     // If we have more than 2 inputs, then each input, except the first is a
     // gradient image. The number of gradient images must match the number of
     // gradient directions.
     //const unsigned int numberOfInputs = this->GetNumberOfInputs();
 
     // There need to be at least 6 gradient directions to be able to compute the
     // tensor basis
     if( m_NumberOfGradientDirections < (L*L + L + 2)/2 + L )
     {
         itkExceptionMacro( << "Not enough gradient directions supplied (" << m_NumberOfGradientDirections << "). At least " << (L*L + L + 2)/2 + L << " needed for SH-order " << L);
     }
 
     // Input must be an itk::VectorImage.
     std::string gradientImageClassName(
                 this->ProcessObject::GetInput(0)->GetNameOfClass());
     if ( strcmp(gradientImageClassName.c_str(),"VectorImage") != 0 )
     {
         itkExceptionMacro( <<
                            "There is only one Gradient image. I expect that to be a VectorImage. "
                            << "But its of type: " << gradientImageClassName );
     }
 
     this->ComputeReconstructionMatrix();
 
     typename GradientImagesType::Pointer img = static_cast< GradientImagesType * >(
                 this->ProcessObject::GetInput(0) );
 
     m_BZeroImage = BZeroImageType::New();
     m_BZeroImage->SetSpacing( img->GetSpacing() );   // Set the image spacing
     m_BZeroImage->SetOrigin( img->GetOrigin() );     // Set the image origin
     m_BZeroImage->SetDirection( img->GetDirection() );  // Set the image direction
     m_BZeroImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
     m_BZeroImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
     m_BZeroImage->Allocate();
 
     m_ODFSumImage = BZeroImageType::New();
     m_ODFSumImage->SetSpacing( img->GetSpacing() );   // Set the image spacing
     m_ODFSumImage->SetOrigin( img->GetOrigin() );     // Set the image origin
     m_ODFSumImage->SetDirection( img->GetDirection() );  // Set the image direction
     m_ODFSumImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
     m_ODFSumImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
     m_ODFSumImage->Allocate();
 
     m_CoefficientImage = CoefficientImageType::New();
     m_CoefficientImage->SetSpacing( img->GetSpacing() );   // Set the image spacing
     m_CoefficientImage->SetOrigin( img->GetOrigin() );     // Set the image origin
     m_CoefficientImage->SetDirection( img->GetDirection() );  // Set the image direction
     m_CoefficientImage->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
     m_CoefficientImage->SetBufferedRegion( img->GetLargestPossibleRegion() );
     m_CoefficientImage->Allocate();
 
     if(m_NormalizationMethod == QBAR_SOLID_ANGLE || m_NormalizationMethod == QBAR_NONNEG_SOLID_ANGLE)
         m_Lambda = 0.0;
 }
 
 template< class T, class TG, class TO, int L, int NODF>
 void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
 ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
                        ThreadIdType )
 {
     typename OutputImageType::Pointer outputImage =
             static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
 
     ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
     oit.GoToBegin();
 
     ImageRegionIterator< BZeroImageType > oit2(m_BZeroImage, outputRegionForThread);
     oit2.GoToBegin();
 
     ImageRegionIterator< FloatImageType > oit3(m_ODFSumImage, outputRegionForThread);
     oit3.GoToBegin();
 
     ImageRegionIterator< CoefficientImageType > oit4(m_CoefficientImage, outputRegionForThread);
     oit4.GoToBegin();
 
     typedef ImageRegionConstIterator< GradientImagesType > GradientIteratorType;
     typedef typename GradientImagesType::PixelType         GradientVectorType;
     typename GradientImagesType::Pointer gradientImagePointer = NULL;
 
     // Would have liked a dynamic_cast here, but seems SGI doesn't like it
     // The enum will ensure that an inappropriate cast is not done
     gradientImagePointer = static_cast< GradientImagesType * >(
                 this->ProcessObject::GetInput(0) );
 
     GradientIteratorType git(gradientImagePointer, outputRegionForThread );
     git.GoToBegin();
 
     // Compute the indicies of the baseline images and gradient images
     std::vector<unsigned int> baselineind; // contains the indicies of
     // the baseline images
     std::vector<unsigned int> gradientind; // contains the indicies of
     // the gradient images
 
     for(GradientDirectionContainerType::ConstIterator gdcit = this->m_GradientDirectionContainer->Begin();
         gdcit != this->m_GradientDirectionContainer->End(); ++gdcit)
     {
         if(gdcit.Value().one_norm() <= 0.0)
             baselineind.push_back(gdcit.Index());
         else
             gradientind.push_back(gdcit.Index());
     }
 
     if( m_DirectionsDuplicated )
     {
         int gradIndSize = gradientind.size();
         for(int i=0; i<gradIndSize; i++)
             gradientind.push_back(gradientind[i]);
     }
 
     while( !git.IsAtEnd() )
     {
         GradientVectorType b = git.Get();
 
         typename NumericTraits<ReferencePixelType>::AccumulateType b0 = NumericTraits<ReferencePixelType>::Zero;
 
         // Average the baseline image pixels
         for(unsigned int i = 0; i < baselineind.size(); ++i)
         {
             b0 += b[baselineind[i]];
         }
         b0 /= this->m_NumberOfBaselineImages;
 
         OdfPixelType odf(0.0);
         typename CoefficientImageType::PixelType coeffPixel(0.0);
         vnl_vector<TO> B(m_NumberOfGradientDirections);
 
         if( (b0 != 0) && (b0 >= m_Threshold) )
         {
             for( unsigned int i = 0; i< m_NumberOfGradientDirections; i++ )
             {
                 B[i] = static_cast<TO>(b[gradientind[i]]);
             }
 
             B = PreNormalize(B, b0);
             if(m_NormalizationMethod == QBAR_SOLID_ANGLE)
             {
                 vnl_vector<TO> coeffs(m_NumberCoefficients);
                 coeffs = ( (*m_CoeffReconstructionMatrix) * B );
                 coeffs[0] += 1.0/(2.0*sqrt(QBALL_ANAL_RECON_PI));
                 odf = ( (*m_SphericalHarmonicBasisMatrix) * coeffs ).data_block();
                 coeffPixel = coeffs.data_block();
             }
             else if(m_NormalizationMethod == QBAR_NONNEG_SOLID_ANGLE)
             {
                 /** this would be the place to implement a non-negative
               * solver for quadratic programming problem:
               * min .5*|| Bc-s ||^2 subject to -CLPc <= 4*pi*ones
               * (refer to MICCAI 2009 Goh et al. "Estimating ODFs with PDF constraints")
               * .5*|| Bc-s ||^2 == .5*c'B'Bc - x'B's + .5*s's
               */
 
                 itkExceptionMacro( << "Nonnegative Solid Angle not yet implemented");
             }
             else
             {
                 vnl_vector<TO> coeffs(m_NumberCoefficients);
                 coeffs = ( (*m_CoeffReconstructionMatrix) * B );
                 coeffs[0] += 1.0/(2.0*sqrt(QBALL_ANAL_RECON_PI));
                 coeffPixel = coeffs.data_block();
                 odf = ( (*m_ReconstructionMatrix) * B ).data_block();
             }
             odf = Normalize(odf, b0);
 
         }
 
         oit.Set( odf );
         oit2.Set( b0 );
         float sum = 0;
         for (int k=0; k<odf.Size(); k++)
             sum += (float) odf[k];
         oit3.Set( sum-1 );
         oit4.Set(coeffPixel);
         ++oit;  // odf image iterator
         ++oit3; // odf sum image iterator
         ++oit2; // b0 image iterator
         ++oit4; // coefficient image iterator
         ++git;  // Gradient  image iterator
     }
 
     std::cout << "One Thread finished reconstruction" << std::endl;
 }
 
 template< class T, class TG, class TO, int L, int NODF>
 void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
 ::tofile2(vnl_matrix<double> *pA, std::string fname)
 {
     vnl_matrix<double> A = (*pA);
     ofstream myfile;
     std::locale C("C");
     std::locale originalLocale = myfile.getloc();
     myfile.imbue(C);
 
     myfile.open (fname.c_str());
     myfile << "A1=[";
     for(int i=0; i<A.rows(); i++)
     {
         for(int j=0; j<A.columns(); j++)
         {
             myfile << A(i,j) << " ";
             if(j==A.columns()-1 && i!=A.rows()-1)
                 myfile << ";";
         }
     }
     myfile << "];";
     myfile.close();
 
     myfile.imbue( originalLocale );
 }
 
 template< class T, class TG, class TO, int L, int NODF>
 void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
 ::Cart2Sph(double x, double y, double z, double *spherical)
 {
     double phi, theta, r;
     r = sqrt(x*x+y*y+z*z);
 
     if( r<mitk::eps )
     {
         theta = M_PI/2;
         phi = M_PI/2;
     }
     else
     {
         theta = acos(z/r);
         phi = atan2(y, x);
     }
     spherical[0] = phi;
     spherical[1] = theta;
     spherical[2] = r;
 }
 
 template< class T, class TG, class TO, int L, int NODF>
 double AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
 ::Yj(int m, int l, double theta, double phi)
 {
     if (m<0)
         return sqrt(2.0)*spherical_harmonic_r(l, -m, theta, phi);
     else if (m==0)
         return spherical_harmonic_r(l, m, theta, phi);
     else
         return pow(-1.0,m)*sqrt(2.0)*spherical_harmonic_i(l, m, theta, phi);
 
     return 0;
 }
 
 template< class T, class TG, class TO, int L, int NODF>
 double AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
 ::Legendre0(int l)
 {
     if( l%2 != 0 )
     {
         return 0;
     }
     else
     {
         double prod1 = 1.0;
         for(int i=1;i<l;i+=2) prod1 *= i;
         double prod2 = 1.0;
         for(int i=2;i<=l;i+=2) prod2 *= i;
         return pow(-1.0,l/2.0)*(prod1/prod2);
     }
 }
 
 template< class T, class TG, class TO, int L, int NODF>
 void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
 ::ComputeReconstructionMatrix()
 {
 
     //for(int i=-6;i<7;i++)
     //  std::cout << boost::math::legendre_p<double>(6, i, 0.65657) << std::endl;
 
     if( m_NumberOfGradientDirections < (L*L + L + 2)/2 + L )
     {
         itkExceptionMacro( << "Not enough gradient directions supplied (" << m_NumberOfGradientDirections << "). At least " << (L*L + L + 2)/2 + L << " needed for SH-order " << L);
     }
 
     {
         // check for duplicate diffusion gradients
         bool warning = false;
         for(GradientDirectionContainerType::ConstIterator gdcit1 = this->m_GradientDirectionContainer->Begin();
             gdcit1 != this->m_GradientDirectionContainer->End(); ++gdcit1)
         {
             for(GradientDirectionContainerType::ConstIterator gdcit2 = this->m_GradientDirectionContainer->Begin();
                 gdcit2 != this->m_GradientDirectionContainer->End(); ++gdcit2)
             {
                 if(gdcit1.Value() == gdcit2.Value() && gdcit1.Index() != gdcit2.Index())
                 {
                     itkWarningMacro( << "Some of the Diffusion Gradients equal each other. Corresponding image data should be averaged before calling this filter." );
                     warning = true;
                     break;
                 }
             }
             if (warning) break;
         }
 
         // handle acquisition schemes where only half of the spherical
         // shell is sampled by the gradient directions. In this case,
         // each gradient direction is duplicated in negative direction.
         vnl_vector<double> centerMass(3);
         centerMass.fill(0.0);
         int count = 0;
         for(GradientDirectionContainerType::ConstIterator gdcit1 = this->m_GradientDirectionContainer->Begin();
             gdcit1 != this->m_GradientDirectionContainer->End(); ++gdcit1)
         {
             if(gdcit1.Value().one_norm() > 0.0)
             {
                 centerMass += gdcit1.Value();
                 count ++;
             }
         }
         centerMass /= count;
         if(centerMass.two_norm() > 0.1)
         {
             m_DirectionsDuplicated = true;
             m_NumberOfGradientDirections *= 2;
         }
     }
 
     vnl_matrix<double> *Q = new vnl_matrix<double>(3, m_NumberOfGradientDirections);
 
     {
         int i = 0;
         for(GradientDirectionContainerType::ConstIterator gdcit = this->m_GradientDirectionContainer->Begin();
             gdcit != this->m_GradientDirectionContainer->End(); ++gdcit)
         {
             if(gdcit.Value().one_norm() > 0.0)
             {
                 double x = gdcit.Value().get(0);
                 double y = gdcit.Value().get(1);
                 double z = gdcit.Value().get(2);
                 double cart[3];
                 Cart2Sph(x,y,z,cart);
                 (*Q)(0,i) = cart[0];
                 (*Q)(1,i) = cart[1];
                 (*Q)(2,i++) = cart[2];
             }
         }
         if(m_DirectionsDuplicated)
         {
             for(GradientDirectionContainerType::ConstIterator gdcit = this->m_GradientDirectionContainer->Begin();
                 gdcit != this->m_GradientDirectionContainer->End(); ++gdcit)
             {
                 if(gdcit.Value().one_norm() > 0.0)
                 {
                     double x = gdcit.Value().get(0);
                     double y = gdcit.Value().get(1);
                     double z = gdcit.Value().get(2);
                     double cart[3];
                     Cart2Sph(x,y,z,cart);
                     (*Q)(0,i) = cart[0];
                     (*Q)(1,i) = cart[1];
                     (*Q)(2,i++) = cart[2];
                 }
             }
         }
     }
 
     int l = L;
     m_NumberCoefficients = (int)(l*l + l + 2.0)/2.0 + l;
     vnl_matrix<double>* B = new vnl_matrix<double>(m_NumberOfGradientDirections,m_NumberCoefficients);
     vnl_matrix<double>* _L = new vnl_matrix<double>(m_NumberCoefficients,m_NumberCoefficients);
     _L->fill(0.0);
     vnl_matrix<double>* LL = new vnl_matrix<double>(m_NumberCoefficients,m_NumberCoefficients);
     LL->fill(0.0);
     vnl_matrix<double>* P = new vnl_matrix<double>(m_NumberCoefficients,m_NumberCoefficients);
     P->fill(0.0);
     vnl_matrix<double>* Inv = new vnl_matrix<double>(m_NumberCoefficients,m_NumberCoefficients);
     P->fill(0.0);
     vnl_vector<int>* lj = new vnl_vector<int>(m_NumberCoefficients);
     m_LP = new vnl_vector<double>(m_NumberCoefficients);
 
     for(unsigned int i=0; i<m_NumberOfGradientDirections; i++)
     {
         for(int k=0; k<=l; k+=2)
         {
             for(int m=-k; m<=k; m++)
             {
                 int j = (k*k + k + 2)/2 + m - 1;
                 (*_L)(j,j) = -k*(k+1);
                 (*m_LP)(j) = -k*(k+1);
                 (*lj)[j] = k;
                 double phi = (*Q)(0,i);
                 double th = (*Q)(1,i);
                 (*B)(i,j) = Yj(m,k,th,phi);
             }
         }
     }
 
     //vnl_matrix<double> temp((*_L)*(*_L));
     LL->update(*_L);
     *LL *= *_L;
     //tofile2(LL,"LL");
 
     for(int i=0; i<m_NumberCoefficients; i++)
     {
         // here we leave out the 2*pi multiplication from Descoteaux
         // this is because we do not want the real integral value
         // but an average value over the equator.
 
         if(m_NormalizationMethod == QBAR_SOLID_ANGLE || m_NormalizationMethod == QBAR_NONNEG_SOLID_ANGLE)
         {
             (*P)(i,i) = 2.0*QBALL_ANAL_RECON_PI*Legendre0((*lj)[i]);
             (*m_LP)(i) *= (*P)(i,i);
         }
         else
         {
             (*P)(i,i) = Legendre0((*lj)[i]);
         }
     }
     m_B_t = new vnl_matrix<double>(B->transpose());
     //tofile2(&m_B_t,"m_B_t");
     vnl_matrix<double> B_t_B = (*m_B_t) * (*B);
     //tofile2(&B_t_B,"B_t_B");
     vnl_matrix<double> lambdaLL(m_NumberCoefficients,m_NumberCoefficients);
     lambdaLL.update((*LL));
     lambdaLL *= m_Lambda;
     //tofile2(&lambdaLL,"lLL");
 
     vnl_matrix<double> tmp( B_t_B + lambdaLL);
     vnl_matrix_inverse<double> *pseudoInverse
             = new vnl_matrix_inverse<double>( tmp );
 
     (*Inv) = pseudoInverse->pinverse();
     //tofile2(Inv,"Inv");
     vnl_matrix<double> temp((*Inv) * (*m_B_t));
     double fac1 = (1.0/(16.0*QBALL_ANAL_RECON_PI*QBALL_ANAL_RECON_PI));
     switch(m_NormalizationMethod)
     {
     case QBAR_ADC_ONLY:
     case QBAR_RAW_SIGNAL:
         break;
     case QBAR_STANDARD:
     case QBAR_B_ZERO_B_VALUE:
     case QBAR_B_ZERO:
     case QBAR_NONE:
         temp = (*P) * temp;
         break;
     case QBAR_SOLID_ANGLE:
         temp = fac1 * (*P) * (*_L) * temp;
         break;
     case QBAR_NONNEG_SOLID_ANGLE:
         break;
     }
 
     //tofile2(&temp,"A");
 
     m_CoeffReconstructionMatrix = new vnl_matrix<TO>(m_NumberCoefficients,m_NumberOfGradientDirections);
     for(int i=0; i<m_NumberCoefficients; i++)
     {
         for(unsigned int j=0; j<m_NumberOfGradientDirections; j++)
         {
             (*m_CoeffReconstructionMatrix)(i,j) = (float) temp(i,j);
         }
     }
 
     // this code goes to the image adapter coeffs->odfs later
 
     int NOdfDirections = NODF;
     vnl_matrix_fixed<double, 3, NODF>* U =
             itk::PointShell<NODF, vnl_matrix_fixed<double, 3, NODF> >::DistributePointShell();
 
     m_SphericalHarmonicBasisMatrix  = new vnl_matrix<TO>(NOdfDirections,m_NumberCoefficients);
     vnl_matrix<double>* sphericalHarmonicBasisMatrix2
             = new vnl_matrix<double>(NOdfDirections,m_NumberCoefficients);
     for(int i=0; i<NOdfDirections; i++)
     {
         double x = (*U)(0,i);
         double y = (*U)(1,i);
         double z = (*U)(2,i);
         double cart[3];
         Cart2Sph(x,y,z,cart);
         (*U)(0,i) = cart[0];
         (*U)(1,i) = cart[1];
         (*U)(2,i) = cart[2];
     }
 
     for(int i=0; i<NOdfDirections; i++)
     {
         for(int k=0; k<=l; k+=2)
         {
             for(int m=-k; m<=k; m++)
             {
                 int j = (k*k + k + 2)/2 + m - 1;
                 double phi = (*U)(0,i);
                 double th = (*U)(1,i);
                 (*m_SphericalHarmonicBasisMatrix)(i,j) = Yj(m,k,th,phi);
                 (*sphericalHarmonicBasisMatrix2)(i,j) = (*m_SphericalHarmonicBasisMatrix)(i,j);
             }
         }
     }
 
     m_ReconstructionMatrix = new vnl_matrix<TO>(NOdfDirections,m_NumberOfGradientDirections);
     *m_ReconstructionMatrix = (*m_SphericalHarmonicBasisMatrix) * (*m_CoeffReconstructionMatrix);
 
 }
 
 template< class T, class TG, class TO, int L, int NODF>
 void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
 ::SetGradientImage(const GradientDirectionContainerType *gradientDirection,
                     const GradientImagesType *gradientImage )
 {
   // Copy Gradient Direction Container
   this->m_GradientDirectionContainer = GradientDirectionContainerType::New();
   for(GradientDirectionContainerType::ConstIterator it = gradientDirection->Begin();
     it != gradientDirection->End(); it++)
   {
     this->m_GradientDirectionContainer->push_back(it.Value());
   }
 
 
     unsigned int numImages = gradientDirection->Size();
     this->m_NumberOfBaselineImages = 0;
     for(GradientDirectionContainerType::Iterator it = this->m_GradientDirectionContainer->Begin();
         it != this->m_GradientDirectionContainer->End(); it++)
     {
         if(it.Value().one_norm() <= 0.0)
         {
             this->m_NumberOfBaselineImages++;
         }
         else // Normalize non-zero gradient directions
         {
             it.Value() = it.Value() / it.Value().two_norm();
         }
     }
 
     this->m_NumberOfGradientDirections = numImages - this->m_NumberOfBaselineImages;
 
     // ensure that the gradient image we received has as many components as
     // the number of gradient directions
     if( gradientImage->GetVectorLength() != this->m_NumberOfBaselineImages + m_NumberOfGradientDirections )
     {
         itkExceptionMacro( << m_NumberOfGradientDirections << " gradients + " << this->m_NumberOfBaselineImages
                            << "baselines = " << m_NumberOfGradientDirections + this->m_NumberOfBaselineImages
                            << " directions specified but image has " << gradientImage->GetVectorLength()
                            << " components.");
     }
 
     this->ProcessObject::SetNthInput( 0, const_cast< GradientImagesType* >(gradientImage) );
 }
 
 template< class T, class TG, class TO, int L, int NODF>
 void AnalyticalDiffusionQballReconstructionImageFilter<T,TG,TO,L,NODF>
 ::PrintSelf(std::ostream& os, Indent indent) const
 {
     std::locale C("C");
     std::locale originalLocale = os.getloc();
     os.imbue(C);
 
     Superclass::PrintSelf(os,indent);
 
     os << indent << "OdfReconstructionMatrix: " << m_ReconstructionMatrix << std::endl;
     if ( m_GradientDirectionContainer )
         os << indent << "GradientDirectionContainer: " << m_GradientDirectionContainer << std::endl;
     else
         os << indent << "GradientDirectionContainer: (Gradient directions not set)" << std::endl;
 
     os << indent << "NumberOfGradientDirections: " <<  m_NumberOfGradientDirections << std::endl;
     os << indent << "NumberOfBaselineImages: " << m_NumberOfBaselineImages << std::endl;
     os << indent << "Threshold for reference B0 image: " << m_Threshold << std::endl;
     os << indent << "BValue: " << m_BValue << std::endl;
     os.imbue( originalLocale );
 }
 
 }
 
 #endif // __itkAnalyticalDiffusionQballReconstructionImageFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
index 101b0ab857..65e1842d1e 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiPhantomGenerationFilter.cpp
@@ -1,390 +1,388 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef __itkDwiPhantomGenerationFilter_cpp
 #define __itkDwiPhantomGenerationFilter_cpp
 
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "itkDwiPhantomGenerationFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <itkOrientationDistributionFunction.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#endif
+#include <boost/progress.hpp>
 
 namespace itk {
 
 //#define QBALL_RECON_PI       3.14159265358979323846
 
 template< class TOutputScalarType >
 DwiPhantomGenerationFilter< TOutputScalarType >
 ::DwiPhantomGenerationFilter()
     : m_BValue(1000)
     , m_SignalScale(1000)
     , m_BaselineImages(0)
     , m_MaxBaseline(0)
     , m_MeanBaseline(0)
     , m_NoiseVariance(0.004)
     , m_GreyMatterAdc(0.01)
     , m_SimulateBaseline(true)
     , m_DefaultBaseline(1000)
 {
     this->SetNumberOfRequiredOutputs (1);
     m_Spacing.Fill(2.5); m_Origin.Fill(0.0);
     m_DirectionMatrix.SetIdentity();
     m_ImageRegion.SetSize(0, 10);
     m_ImageRegion.SetSize(1, 10);
     m_ImageRegion.SetSize(2, 10);
 
     typename OutputImageType::Pointer outImage = OutputImageType::New();
 
     outImage->SetSpacing( m_Spacing );   // Set the image spacing
     outImage->SetOrigin( m_Origin );     // Set the image origin
     outImage->SetDirection( m_DirectionMatrix );  // Set the image direction
     outImage->SetLargestPossibleRegion( m_ImageRegion );
     outImage->SetBufferedRegion( m_ImageRegion );
     outImage->SetRequestedRegion( m_ImageRegion );
     outImage->SetVectorLength(QBALL_ODFSIZE);
     outImage->Allocate();
     // ITKv4 migration fix : removing OutputImageType::PixelType(0.0)
     // the conversion is handled internally by the itk::Image
     typename OutputImageType::PixelType fillValue(0.0);
     outImage->FillBuffer( fillValue );
 
     this->SetNthOutput (0, outImage);
 
 }
 
 template< class TOutputScalarType >
 void DwiPhantomGenerationFilter< TOutputScalarType >
 ::GenerateTensors()
 {
     MITK_INFO << "Generating tensors";
 
     for (int i=0; i<m_SignalRegions.size(); i++)
     {
         float ADC = m_TensorADC.at(i);
         float FA = m_TensorFA.at(i);
         itk::DiffusionTensor3D<float> kernel;
         kernel.Fill(0);
         float e1=ADC*(1+2*FA/sqrt(3-2*FA*FA));
         float e2=ADC*(1-FA/sqrt(3-2*FA*FA));
         float e3=e2;
         kernel.SetElement(0,e1);
         kernel.SetElement(3,e2);
         kernel.SetElement(5,e3);
 
         if (m_SimulateBaseline)
         {
             double l2 = GetTensorL2Norm(kernel);
             if (l2>m_MaxBaseline)
                 m_MaxBaseline = l2;
         }
 
         MITK_INFO << "Kernel FA: " << kernel.GetFractionalAnisotropy();
         vnl_vector_fixed<double, 3> kernelDir; kernelDir[0]=1; kernelDir[1]=0; kernelDir[2]=0;
 
         itk::DiffusionTensor3D<float> tensor;
         vnl_vector_fixed<double, 3> dir = m_TensorDirection.at(i);
         MITK_INFO << "Tensor direction: " << dir;
 
         dir.normalize();
 
         vnl_vector_fixed<double, 3> axis = vnl_cross_3d(kernelDir, dir); axis.normalize();
         vnl_quaternion<double> rotation(axis, acos(dot_product(kernelDir, dir)));
         rotation.normalize();
         vnl_matrix_fixed<double, 3, 3> matrix = rotation.rotation_matrix_transpose();
 
         vnl_matrix_fixed<double, 3, 3> tensorMatrix;
         tensorMatrix[0][0] = kernel[0]; tensorMatrix[0][1] = kernel[1]; tensorMatrix[0][2] = kernel[2];
         tensorMatrix[1][0] = kernel[1]; tensorMatrix[1][1] = kernel[3]; tensorMatrix[1][2] = kernel[4];
         tensorMatrix[2][0] = kernel[2]; tensorMatrix[2][1] = kernel[4]; tensorMatrix[2][2] = kernel[5];
 
         tensorMatrix = matrix.transpose()*tensorMatrix*matrix;
         tensor[0] = tensorMatrix[0][0]; tensor[1] = tensorMatrix[0][1]; tensor[2] = tensorMatrix[0][2];
         tensor[3] = tensorMatrix[1][1]; tensor[4] = tensorMatrix[1][2]; tensor[5] = tensorMatrix[2][2];
 
         m_TensorList.push_back(tensor);
     }
 }
 
 template< class TOutputScalarType >
 void DwiPhantomGenerationFilter< TOutputScalarType >::AddNoise(typename OutputImageType::PixelType& pix)
 {
     for( unsigned int i=0; i<m_GradientList.size(); i++)
     {
         float signal = pix[i];
         float val = sqrt(pow(signal + m_SignalScale*m_RandGen->GetNormalVariate(0.0, m_NoiseVariance), 2) +  pow(m_SignalScale*m_RandGen->GetNormalVariate(0.0, m_NoiseVariance),2));
         pix[i] += val;
     }
 }
 
 template< class TOutputScalarType >
 typename DwiPhantomGenerationFilter< TOutputScalarType >::OutputImageType::PixelType
 DwiPhantomGenerationFilter< TOutputScalarType >::SimulateMeasurement(itk::DiffusionTensor3D<float>& T, float weight)
 {
     typename OutputImageType::PixelType out;
     out.SetSize(m_GradientList.size());
     out.Fill(0);
 
     TOutputScalarType s0 = m_DefaultBaseline;
     if (m_SimulateBaseline)
         s0 = (GetTensorL2Norm(T)/m_MaxBaseline)*m_SignalScale;
 
     for( unsigned int i=0; i<m_GradientList.size(); i++)
     {
         GradientType g = m_GradientList[i];
 
         if (g.GetNorm()>0.0001)
         {
             itk::DiffusionTensor3D<float> S;
             S[0] = g[0]*g[0];
             S[1] = g[1]*g[0];
             S[2] = g[2]*g[0];
             S[3] = g[1]*g[1];
             S[4] = g[2]*g[1];
             S[5] = g[2]*g[2];
 
             double D = T[0]*S[0] + T[1]*S[1] + T[2]*S[2] +
                        T[1]*S[1] + T[3]*S[3] + T[4]*S[4] +
                        T[2]*S[2] + T[4]*S[4] + T[5]*S[5];
 
             // check for corrupted tensor and generate signal
             if (D>=0)
             {
                 D = weight*s0*exp ( -m_BValue * D );
                 out[i] = static_cast<TOutputScalarType>( D );
             }
         }
         else
             out[i] = s0;
     }
 
     return out;
 }
 
 template< class TOutputScalarType >
 void DwiPhantomGenerationFilter< TOutputScalarType >
 ::GenerateData()
 {
     if (m_NoiseVariance < 0)
         m_NoiseVariance = 0.001;
 
     if (!m_SimulateBaseline)
     {
         MITK_INFO << "Baseline image values are set to default. Noise variance value is treated as SNR!";
         if (m_NoiseVariance <= 0)
             m_NoiseVariance = 0.0001;
         if (m_NoiseVariance>99)
             m_NoiseVariance = 0;
         else
         {
             m_NoiseVariance = m_DefaultBaseline/(m_NoiseVariance*m_SignalScale);
             m_NoiseVariance *= m_NoiseVariance;
         }
     }
 
     m_RandGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
     m_RandGen->SetSeed();
 
     typename OutputImageType::Pointer outImage = OutputImageType::New();
     outImage->SetSpacing( m_Spacing );
     outImage->SetOrigin( m_Origin );
     outImage->SetDirection( m_DirectionMatrix );
     outImage->SetLargestPossibleRegion( m_ImageRegion );
     outImage->SetBufferedRegion( m_ImageRegion );
     outImage->SetRequestedRegion( m_ImageRegion );
     outImage->SetVectorLength(m_GradientList.size());
     outImage->Allocate();
     typename OutputImageType::PixelType pix;
     pix.SetSize(m_GradientList.size());
     pix.Fill(0.0);
     outImage->FillBuffer(pix);
     this->SetNthOutput (0, outImage);
 
     double minSpacing = m_Spacing[0];
     if (m_Spacing[1]<minSpacing)
         minSpacing = m_Spacing[1];
     if (m_Spacing[2]<minSpacing)
         minSpacing = m_Spacing[2];
 
     m_DirectionImageContainer = ItkDirectionImageContainer::New();
     for (int i=0; i<m_SignalRegions.size(); i++)
     {
         itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
         ItkDirectionImage::Pointer img = ItkDirectionImage::New();
         img->SetSpacing( m_Spacing );
         img->SetOrigin( m_Origin );
         img->SetDirection( m_DirectionMatrix );
         img->SetRegions( m_ImageRegion );
         img->Allocate();
         img->FillBuffer(nullVec);
         m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
     }
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( m_Spacing );
     m_NumDirectionsImage->SetOrigin( m_Origin );
     m_NumDirectionsImage->SetDirection( m_DirectionMatrix );
     m_NumDirectionsImage->SetRegions( m_ImageRegion );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     m_SNRImage = ItkFloatImgType::New();
     m_SNRImage->SetSpacing( m_Spacing );
     m_SNRImage->SetOrigin( m_Origin );
     m_SNRImage->SetDirection( m_DirectionMatrix );
     m_SNRImage->SetRegions( m_ImageRegion );
     m_SNRImage->Allocate();
     m_SNRImage->FillBuffer(0);
 
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     m_BaselineImages = 0;
     for( unsigned int i=0; i<m_GradientList.size(); i++)
         if (m_GradientList[i].GetNorm()<=0.0001)
             m_BaselineImages++;
 
     typedef ImageRegionIterator<OutputImageType>      IteratorOutputType;
     IteratorOutputType it (outImage, m_ImageRegion);
 
     // isotropic tensor
     itk::DiffusionTensor3D<float> isoTensor;
     isoTensor.Fill(0);
     float e1 = m_GreyMatterAdc;
     float e2 = m_GreyMatterAdc;
     float e3 = m_GreyMatterAdc;
     isoTensor.SetElement(0,e1);
     isoTensor.SetElement(3,e2);
     isoTensor.SetElement(5,e3);
     m_MaxBaseline = GetTensorL2Norm(isoTensor);
 
     GenerateTensors();
 
     // simulate measurement
     m_MeanBaseline = 0;
     double noiseStdev = sqrt(m_NoiseVariance);
     while(!it.IsAtEnd())
     {
         pix = it.Get();
         typename OutputImageType::IndexType index = it.GetIndex();
 
         int numDirs = 0;
         for (int i=0; i<m_SignalRegions.size(); i++)
         {
             ItkUcharImgType::Pointer region = m_SignalRegions.at(i);
 
             if (region->GetPixel(index)!=0)
             {
                 numDirs++;
                 pix += SimulateMeasurement(m_TensorList[i], m_TensorWeight[i]);
 
                 // set direction image pixel
                 ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
                 itk::Vector< float, 3 > pixel = img->GetPixel(index);
                 vnl_vector_fixed<double, 3> dir = m_TensorDirection.at(i);
                 dir.normalize();
                 dir *= m_TensorWeight.at(i);
                 pixel.SetElement(0, dir[0]);
                 pixel.SetElement(1, dir[1]);
                 pixel.SetElement(2, dir[2]);
                 img->SetPixel(index, pixel);
 
                 vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
                 itk::ContinuousIndex<double, 3> center;
                 center[0] = index[0];
                 center[1] = index[1];
                 center[2] = index[2];
                 itk::Point<double> worldCenter;
                 outImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
                 itk::Point<double> worldStart;
                 worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
                 worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
                 worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
                 vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
                 container->GetPointIds()->InsertNextId(id);
                 itk::Point<double> worldEnd;
                 worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
                 worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
                 worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
                 id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
                 container->GetPointIds()->InsertNextId(id);
                 m_VtkCellArray->InsertNextCell(container);
             }
         }
 
         if (numDirs>1)
         {
             for (int i=0; i<m_GradientList.size(); i++)
                 pix[i] /= numDirs;
         }
         else if (numDirs==0)
         {
             if (m_SimulateBaseline)
                 pix = SimulateMeasurement(isoTensor, 1.0);
             else
                 pix.Fill(0.0);
         }
 
         m_MeanBaseline += pix[0];
         it.Set(pix);
         m_NumDirectionsImage->SetPixel(index, numDirs);
         if (m_NoiseVariance>0)
             m_SNRImage->SetPixel(index, pix[0]/(noiseStdev*m_SignalScale));
         ++it;
     }
     m_MeanBaseline /= m_ImageRegion.GetNumberOfPixels();
     if (m_NoiseVariance>0)
         MITK_INFO << "Mean SNR: " << m_MeanBaseline/(noiseStdev*m_SignalScale);
     else
         MITK_INFO << "No noise added";
 
     // add rician noise
     it.GoToBegin();
     while(!it.IsAtEnd())
     {
         pix = it.Get();
         AddNoise(pix);
         it.Set(pix);
         ++it;
     }
 
     // generate fiber bundle
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
     m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
 }
 template< class TOutputScalarType >
 double DwiPhantomGenerationFilter< TOutputScalarType >::GetTensorL2Norm(itk::DiffusionTensor3D<float>& T)
 {
     return sqrt(T[0]*T[0] + T[3]*T[3] + T[5]*T[5] + T[1]*T[2]*2.0 + T[2]*T[4]*2.0 + T[1]*T[4]*2.0);
 }
 
 }
 
 #endif // __itkDwiPhantomGenerationFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
index 03bef35ea5..d92204518a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.cpp
@@ -1,524 +1,522 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef __itkFiniteDiffOdfMaximaExtractionFilter_cpp
 #define __itkFiniteDiffOdfMaximaExtractionFilter_cpp
 
 #include "itkFiniteDiffOdfMaximaExtractionFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <vnl/vnl_vector.h>
 #include <itkOrientationDistributionFunction.h>
 #include <itkContinuousIndex.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
-#ifndef Q_MOC_RUN
-#  include <boost/math/special_functions.hpp>
-#  include <boost/progress.hpp>
-#endif
+#include <boost/math/special_functions.hpp>
+#include <boost/progress.hpp>
 
 
 using namespace boost::math;
 
 namespace itk {
 
 
 static bool CompareVectors(const vnl_vector_fixed< double, 3 >& v1, const vnl_vector_fixed< double, 3 >& v2)
 {
     return (v1.magnitude()>v2.magnitude());
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::FiniteDiffOdfMaximaExtractionFilter()
     : m_Toolkit(FSL)
     , m_MaxNumPeaks(2)
     , m_PeakThreshold(0.4)
     , m_ClusteringThreshold(0.9)
     , m_AngularThreshold(0.7)
     , m_NumCoeffs((ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder)
     , m_NormalizationMethod(MAX_VEC_NORM)
     , m_AbsolutePeakThreshold(0)
 {
     this->SetNumberOfRequiredInputs(1);
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::FindCandidatePeaks(OdfType& odf, double thr, std::vector< DirectionType >& container)
 {
     double gfa = odf.GetGeneralizedFractionalAnisotropy();
     //Find the peaks using a finite difference method
     bool flag = true;
     vnl_vector_fixed< bool, NrOdfDirections > used; used.fill(false);
     //Find the peaks
     for (int i=0; i<NrOdfDirections; i++)
     {
         if (used[i])
             continue;
 
         double val = odf.GetElement(i);
         if (val>thr && val*gfa>m_AbsolutePeakThreshold)  // limit to one hemisphere ???
         {
             flag = true;
             std::vector< int > neighbours = odf.GetNeighbors(i);
             for (int j=0; j<neighbours.size(); j++)
                 if (val<=odf.GetElement(neighbours.at(j)))
                 {
                     flag = false;
                     break;
                 }
             if (flag)   // point is a peak
             {
                 container.push_back(odf.GetDirection(i).normalize());
                 used[i] = true;
                 for (int j=0; j<neighbours.size(); j++)
                     used[neighbours.at(j)] = true;
             }
         }
     }
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 std::vector< vnl_vector_fixed< double, 3 > >  FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>::MeanShiftClustering(std::vector< vnl_vector_fixed< double, 3 > >& inDirs)
 {
     std::vector< DirectionType > outDirs;
     if (inDirs.empty())
         return inDirs;
 
     DirectionType oldMean, currentMean, workingMean;
     std::vector< int > touched;
 
     // initialize
     touched.resize(inDirs.size(), 0);
     bool free = true;
     currentMean = inDirs[0];  // initialize first seed
     while (free)
     {
         oldMean.fill(0.0);
 
         // start mean-shift clustering
         float angle = 0.0;
         int counter = 0;
         while ((currentMean-oldMean).magnitude()>0.0001)
         {
             counter = 0;
             oldMean = currentMean;
             workingMean = oldMean;
             workingMean.normalize();
             currentMean.fill(0.0);
             for (int i=0; i<inDirs.size(); i++)
             {
                 angle = dot_product(workingMean, inDirs[i]);
                 if (angle>=m_ClusteringThreshold)
                 {
                     currentMean += inDirs[i];
                     touched[i] = 1;
                     counter++;
                 }
                 else if (-angle>=m_ClusteringThreshold)
                 {
                     currentMean -= inDirs[i];
                     touched[i] = 1;
                     counter++;
                 }
             }
         }
 
         // found stable mean
         if (counter>0)
         {
             float mag = currentMean.magnitude();
             if (mag>0)
             {
                 currentMean /= mag;
                 outDirs.push_back(currentMean);
             }
         }
 
         // find next unused seed
         free = false;
         for (int i=0; i<touched.size(); i++)
             if (touched[i]==0)
             {
                 currentMean = inDirs[i];
                 free = true;
             }
     }
 
     if (inDirs.size()==outDirs.size())
     {
         return outDirs;
     }
     else
         return MeanShiftClustering(outDirs);
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::BeforeThreadedGenerateData()
 {
     typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
     itk::Vector<double,3> spacing = ShCoeffImage->GetSpacing();
     double minSpacing = spacing[0];
     if (spacing[1]<minSpacing)
         minSpacing = spacing[1];
     if (spacing[2]<minSpacing)
         minSpacing = spacing[2];
 
     mitk::Point3D origin = ShCoeffImage->GetOrigin();
     itk::Matrix<double, 3, 3> direction = ShCoeffImage->GetDirection();
     ImageRegion<3> imageRegion = ShCoeffImage->GetLargestPossibleRegion();
 
     if (m_MaskImage.IsNotNull())
     {
         origin = m_MaskImage->GetOrigin();
         direction = m_MaskImage->GetDirection();
         imageRegion = m_MaskImage->GetLargestPossibleRegion();
     }
 
     m_DirectionImageContainer = ItkDirectionImageContainer::New();
     for (int i=0; i<m_MaxNumPeaks; i++)
     {
         itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
         ItkDirectionImage::Pointer img = ItkDirectionImage::New();
         img->SetSpacing( spacing );
         img->SetOrigin( origin );
         img->SetDirection( direction );
         img->SetRegions( imageRegion );
         img->Allocate();
         img->FillBuffer(nullVec);
         m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
     }
     if (m_MaskImage.IsNull())
     {
         m_MaskImage = ItkUcharImgType::New();
         m_MaskImage->SetSpacing( spacing );
         m_MaskImage->SetOrigin( origin );
         m_MaskImage->SetDirection( direction );
         m_MaskImage->SetRegions( imageRegion );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( spacing );
     m_NumDirectionsImage->SetOrigin( origin );
     m_NumDirectionsImage->SetDirection( direction );
     m_NumDirectionsImage->SetRegions( imageRegion );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     this->SetNumberOfOutputs(m_MaxNumPeaks);
 
     // calculate SH basis
     OdfType odf;
     vnl_matrix_fixed<double, 3, NrOdfDirections>* directions = odf.GetDirections();
     vnl_matrix< double > sphCoords;
     std::vector< DirectionType > dirs;
     for (int i=0; i<NrOdfDirections; i++)
         dirs.push_back(directions->get_column(i));
     Cart2Sph(dirs, sphCoords);                          // convert candidate peaks to spherical angles
     m_ShBasis = CalcShBasis(sphCoords);                // evaluate spherical harmonics at each peak
 
     MITK_INFO << "Starting finite differences maximum extraction";
     MITK_INFO << "ODF sampling points: " << NrOdfDirections;
     MITK_INFO << "SH order: " << ShOrder;
     MITK_INFO << "Maximum peaks: " << m_MaxNumPeaks;
     MITK_INFO << "Relative threshold: " << m_PeakThreshold;
     MITK_INFO << "Absolute threshold: " << m_AbsolutePeakThreshold;
     MITK_INFO << "Clustering threshold: " << m_ClusteringThreshold;
     MITK_INFO << "Angular threshold: " << m_AngularThreshold;
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::AfterThreadedGenerateData()
 {
     MITK_INFO << "Generating vector field";
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
     ImageRegionConstIterator< CoefficientImageType > cit(ShCoeffImage, ShCoeffImage->GetLargestPossibleRegion() );
 
     mitk::Vector3D spacing = ShCoeffImage->GetSpacing();
     double minSpacing = spacing[0];
     if (spacing[1]<minSpacing)
         minSpacing = spacing[1];
     if (spacing[2]<minSpacing)
         minSpacing = spacing[2];
 
     int maxProgress = ShCoeffImage->GetLargestPossibleRegion().GetSize()[0]*ShCoeffImage->GetLargestPossibleRegion().GetSize()[1]*ShCoeffImage->GetLargestPossibleRegion().GetSize()[2];
     boost::progress_display disp(maxProgress);
 
     while( !cit.IsAtEnd() )
     {
         ++disp;
 
         typename CoefficientImageType::IndexType index = cit.GetIndex();
         if (m_MaskImage->GetPixel(index)==0)
         {
             ++cit;
             continue;
         }
 
         for (int i=0; i<m_DirectionImageContainer->Size(); i++)
         {
             ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
             itk::Vector< float, 3 > pixel = img->GetPixel(index);
             DirectionType dir; dir[0] = pixel[0]; dir[1] = pixel[1]; dir[2] = pixel[2];
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             itk::ContinuousIndex<double, 3> center;
             center[0] = index[0];
             center[1] = index[1];
             center[2] = index[2];
             itk::Point<double> worldCenter;
             m_MaskImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
 
             itk::Point<double> worldStart;
             worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
             worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
             worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
             vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             itk::Point<double> worldEnd;
             worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
             worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
             worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
             id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             m_VtkCellArray->InsertNextCell(container);
         }
         ++cit;
     }
 
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
     m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
 
     for (int i=0; i<m_DirectionImageContainer->Size(); i++)
     {
         ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
         this->SetNthOutput(i, img);
     }
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, ThreadIdType threadID )
 {
     typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
 
     ImageRegionConstIterator< CoefficientImageType > cit(ShCoeffImage, outputRegionForThread );
 
     OdfType odf;
     while( !cit.IsAtEnd() )
     {
         typename CoefficientImageType::IndexType index = cit.GetIndex();
         if (m_MaskImage->GetPixel(index)==0)
         {
             ++cit;
             continue;
         }
 
         CoefficientPixelType c = cit.Get();
 
         // calculate ODF
         double max = 0;
         odf.Fill(0.0);
         for (int i=0; i<NrOdfDirections; i++)
         {
             for (int j=0; j<m_NumCoeffs; j++)
                 odf[i] += c[j]*m_ShBasis(i,j);
             if (odf[i]>max)
                 max = odf[i];
         }
         if (max<0.0001)
         {
             ++cit;
             continue;
         }
 
         std::vector< DirectionType > candidates, peaks, temp;
         peaks.clear();
         max *= m_PeakThreshold;                         // relative threshold
         FindCandidatePeaks(odf, max, candidates);       // find all local maxima
         candidates = MeanShiftClustering(candidates);   // cluster maxima
 
         vnl_matrix< double > shBasis, sphCoords;
         Cart2Sph(candidates, sphCoords);                // convert candidate peaks to spherical angles
         shBasis = CalcShBasis(sphCoords);            // evaluate spherical harmonics at each peak
         max = 0.0;
         for (int i=0; i<candidates.size(); i++)         // scale peaks according to ODF value
         {
             double val = 0;
             for (int j=0; j<m_NumCoeffs; j++)
                 val += c[j]*shBasis(i,j);
             if (val>max)
                 max = val;
             peaks.push_back(candidates[i]*val);
         }
         std::sort( peaks.begin(), peaks.end(), CompareVectors );  // sort peaks
 
         // kick out directions to close to a larger direction (too far away to cluster but too close to keep)
         int m = peaks.size();
         if ( m>m_DirectionImageContainer->Size() )
             m = m_DirectionImageContainer->Size();
         for (int i=0; i<m; i++)
         {
             DirectionType v1 = peaks.at(i);
             double val = v1.magnitude();
             if (val<max*m_PeakThreshold || val<m_AbsolutePeakThreshold)
                 break;
 
             bool flag = true;
             for (int j=0; j<peaks.size(); j++)
                 if (i!=j)
                 {
                     DirectionType v2 = peaks.at(j);
                     double val2 = v2.magnitude();
                     double angle = fabs(dot_product(v1,v2)/(val*val2));
                     if (angle>m_AngularThreshold && val<val2)
                     {
                         flag = false;
                         break;
                     }
                 }
 
             if (flag)
                 temp.push_back(v1);
         }
         peaks = temp;
 
         // fill output image
         int num = peaks.size();
         if ( num>m_DirectionImageContainer->Size() )
             num = m_DirectionImageContainer->Size();
         for (int i=0; i<num; i++)
         {
             vnl_vector<double> dir = peaks.at(i);
 
             ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
 
             switch (m_NormalizationMethod)
             {
             case NO_NORM:
                 break;
             case SINGLE_VEC_NORM:
                 dir.normalize();
                 break;
             case MAX_VEC_NORM:
                 dir /= max;
                 break;
             }
 //            dir[0] = -dir[0];
 //            dir[2] = -dir[2];
 
             dir = m_MaskImage->GetDirection()*dir;
             itk::Vector< float, 3 > pixel;
             pixel.SetElement(0, dir[0]);
             pixel.SetElement(1, dir[1]);
             pixel.SetElement(2, dir[2]);
             img->SetPixel(index, pixel);
         }
         m_NumDirectionsImage->SetPixel(index, num);
         ++cit;
     }
     MITK_INFO << "Thread " << threadID << " finished extraction";
 }
 
 // convert cartesian to spherical coordinates
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::Cart2Sph(const std::vector< DirectionType >& dir, vnl_matrix<double>& sphCoords)
 {
     sphCoords.set_size(dir.size(), 2);
 
     for (int i=0; i<dir.size(); i++)
     {
         double mag = dir[i].magnitude();
 
         if( mag<0.0001 )
         {
             sphCoords(i,0) = M_PI/2; // theta
             sphCoords(i,1) = M_PI/2; // phi
         }
         else
         {
             sphCoords(i,0) = acos(dir[i](2)/mag); // theta
             sphCoords(i,1) = atan2(dir[i](1), dir[i](0)); // phi
         }
     }
 }
 
 // generate spherical harmonic values of the desired order for each input direction
 template< class PixelType, int ShOrder, int NrOdfDirections >
 vnl_matrix<double> FiniteDiffOdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::CalcShBasis(vnl_matrix<double>& sphCoords)
 {
     int M = sphCoords.rows();
     int j, m; double mag, plm;
     vnl_matrix<double> shBasis;
     shBasis.set_size(M, m_NumCoeffs);
 
     for (int p=0; p<M; p++)
     {
         j=0;
         for (int l=0; l<=ShOrder; l=l+2)
             for (m=-l; m<=l; m++)
             {
                 switch (m_Toolkit)
                 {
                 case FSL:
                 plm = legendre_p<double>(l,abs(m),cos(sphCoords(p,0)));
                 mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
 
                 if (m<0)
                     shBasis(p,j) = sqrt(2.0)*mag*cos(fabs((double)m)*sphCoords(p,1));
                 else if (m==0)
                     shBasis(p,j) = mag;
                 else
                     shBasis(p,j) = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*sphCoords(p,1));
                     break;
                 case MRTRIX:
 
                 plm = legendre_p<double>(l,abs(m),-cos(sphCoords(p,0)));
                 mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
                 if (m>0)
                     shBasis(p,j) = mag*cos(m*sphCoords(p,1));
                 else if (m==0)
                     shBasis(p,j) = mag;
                 else
                     shBasis(p,j) = mag*sin(-m*sphCoords(p,1));
                     break;
                 }
 
                 j++;
             }
     }
     return shBasis;
 }
 
 }
 
 #endif // __itkFiniteDiffOdfMaximaExtractionFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
index f44113d635..23a79eb8cf 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkOdfMaximaExtractionFilter.cpp
@@ -1,632 +1,629 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef __itkOdfMaximaExtractionFilter_cpp
 #define __itkOdfMaximaExtractionFilter_cpp
 
 
 #include "itkOdfMaximaExtractionFilter.h"
 #include <itkImageRegionIterator.h>
 #include <itkContinuousIndex.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#  include <boost/math/special_functions.hpp>
-#endif
-
+#include <boost/progress.hpp>
+#include <boost/math/special_functions.hpp>
 #include <vnl/vnl_det.h>
 #include <vnl/vnl_trace.h>
 
 using namespace boost::math;
 using namespace std;
 
 namespace itk {
 
 template< class TOdfPixelType >
 OdfMaximaExtractionFilter< TOdfPixelType >::OdfMaximaExtractionFilter():
     m_NormalizationMethod(MAX_VEC_NORM),
     m_PeakThreshold(0.2),
     m_MaxNumPeaks(10),
     m_ShCoeffImage(NULL),
     m_OutputFiberBundle(NULL),
     m_NumDirectionsImage(NULL),
     m_DirectionImageContainer(NULL)
 {
 
 }
 
 // solve ax? + bx? + cx + d = 0 using cardanos method
 template< class TOdfPixelType >
 bool OdfMaximaExtractionFilter<TOdfPixelType>::ReconstructQballImage()
 {
     if (m_ShCoeffImage.IsNotNull())
     {
         cout << "Using preset coefficient image\n";
         return true;
     }
 
     cout << "Starting qball reconstruction\n";
     try {
         QballReconstructionFilterType::Pointer filter = QballReconstructionFilterType::New();
         filter->SetGradientImage( m_DiffusionGradients, m_DiffusionImage );
         filter->SetBValue(m_Bvalue);
         filter->SetLambda(0.006);
         filter->SetNormalizationMethod(QballReconstructionFilterType::QBAR_SOLID_ANGLE);
         filter->Update();
         m_ShCoeffImage = filter->GetCoefficientImage();
         if (m_ShCoeffImage.IsNull())
             return false;
         return true;
     }
     catch (...)
     {
         return false;
     }
 }
 
 // solve ax³ + bx² + cx + d = 0 using cardanos method
 template< class TOdfPixelType >
 std::vector<double> OdfMaximaExtractionFilter< TOdfPixelType >
 ::SolveCubic(const double& a, const double& b, const double& c, const double& d)
 {
     double A, B, p, q, r, D, offset, ee, tmp, root;
     vector<double> roots;
     double inv3 = 1.0/3.0;
 
     if (a!=0) // solve ax³ + bx² + cx + d = 0
     {
         p = b/a; q = c/a; r = d/a; // x³ + px² + qx + r = 0
         A = q-p*p*inv3;
         B = (2.0*p*p*p-9.0*p*q+27.0*r)/27.0;
         A = A*inv3;
         B = B*0.5;
         D = B*B+A*A*A;
         offset = p*inv3;
 
         if (D>0.0) // one real root
         {
             ee = sqrt(D);
             tmp = -B+ee;  root  = cbrt(tmp);
             tmp = -B-ee;  root += cbrt(tmp);
             root -= offset; roots.push_back(root);
         }
         else if (D<0.0) // three real roots
         {
             ee = sqrt(-D);
             double tmp2 = -B;
             double angle =  2.0*inv3*atan(ee/(sqrt(tmp2*tmp2+ee*ee)+tmp2));
             double sqrt3 = sqrt(3.0);
             tmp = cos(angle);
             tmp2 = sin(angle);
             ee = sqrt(-A);
             root = 2*ee*tmp-offset;             roots.push_back(root);
             root = -ee*(tmp+sqrt3*tmp2)-offset; roots.push_back(root);
             root = -ee*(tmp-sqrt3*tmp2)-offset; roots.push_back(root);
         }
         else // one or two real roots
         {
             tmp=-B;
             tmp=cbrt(tmp);
             root=2*tmp-offset;      roots.push_back(root);
             if (A!=0 || B!=0)
                 root=-tmp-offset;   roots.push_back(root);
         }
     }
     else if (b!=0) // solve bx² + cx + d = 0
     {
         D = c*c-4*b*d;
         if (D>0)
         {
             tmp = sqrt(D);
             root = (-c+tmp)/(2.0*b); roots.push_back(root);
             root = (-c-tmp)/(2.0*b); roots.push_back(root);
         }
         else if (D==0)
             root = -c/(2.0*b); roots.push_back(root);
     }
     else if (c!=0) // solve cx + d = 0
         root = -d/c; roots.push_back(root);
 
     return roots;
 }
 
 template< class TOdfPixelType >
 double OdfMaximaExtractionFilter< TOdfPixelType >
 ::ODF_dtheta(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
 {
     double dtheta=(G-7*E)*sn*sn + (7*F-35*D-H)*sn*cs + (H+C-F-3*A-5*D)*sn + (0.5*E+B+0.5*G)*cs -0.5*G+3.5*E;
     return dtheta;
 }
 
 template< class TOdfPixelType >
 double OdfMaximaExtractionFilter< TOdfPixelType >
 ::ODF_dtheta2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
 {
     double dtheta2=4*(G-7*E)*sn*cs + 2*(7*F-35*D-H)*(2*cs*cs-1) + 2*(H+C-F-3*A-5*D)*cs -(E+2*B+G)*sn;
     return dtheta2;
 }
 
 template< class TOdfPixelType >
 double OdfMaximaExtractionFilter< TOdfPixelType >
 ::ODF_dphi2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H)
 {
     double dphi2=35*D*((1+cs)*(1+cs)/4)+(3*A-30*D)*(1+cs)/2.0+3*D-A + 0.5*(7*E*(1+cs)/2.0-3*E+B)*sn + (7*F*(1+cs)/2+C-F)*(1-cs)/2.0 + G*sn*(1-cs)/4.0 + H*((1-cs)*(1-cs)/4);
     return dphi2;
 }
 
 template< class TOdfPixelType >
 void OdfMaximaExtractionFilter< TOdfPixelType >
 ::FindCandidatePeaks(const CoefficientPixelType& SHcoeff)
 {
     const double thr = 0.03;             // threshold on the derivative of the ODF with respect to theta
     const double phi_step = 0.005;       // step size for 1D exhaustive search on phi
     bool highRes;                        // when close to maxima increase resolution
     double mag, Y, Yp, sn, cs;
     double phi, dPhi;
     double A, B, C, D, E, F, G, H, Bp, Cp, Ep, Fp, Gp, Hp, Bs, Cs, Es, Fs, Gs, Hs;
     CoefficientPixelType a, ap;
     a = SHcoeff; ap = SHcoeff;
 
     m_CandidatePeaks.clear();   // clear peaks of last voxel
 
     for (int adaptiveStepwidth=0; adaptiveStepwidth<=1; adaptiveStepwidth++)
     {
     phi=0;
     while (phi<(2*M_PI)) // phi exhaustive search 0..pi
     {
         // calculate 4th order SH representtaion of ODF and according derivative
         for (int l=0; l<=4; l=l+2)
         {
             for (int m=-l; m<=l; m++)
             {
                 int j=l*(l+1)/2+m;
                 if (m<0)
                 {
                     mag = sqrt(((2*l+1)/(2*M_PI))*factorial<double>(l+m)/factorial<double>(l-m));
                     Y = mag*cos(m*phi);
                     Yp = -m*mag*sin(m*phi);
                 }
                 else if (m==0)
                 {
                     Y = sqrt((2*l+1)/(4*M_PI));
                     Yp = 0;
                 }
                 else
                 {
                     mag = pow(-1.0,m)*sqrt(((2*l+1)/(2*M_PI))*factorial<double>(l-m)/factorial<double>(l+m));
                     Y = mag*sin(m*phi);
                     Yp = m*mag*cos(m*phi);
                 }
                 a[j] = SHcoeff[j]*Y;
                 ap[j] = SHcoeff[j]*Yp;
             }
         }
 
         // ODF
         A=0.5*a[3]; B=-3*(a[2]+a[4]); C=3*(a[1]+a[5]); D=0.125*a[10]; E=-2.5*(a[9]+a[11]);
         F=7.5*(a[8]+a[12]); G=-105*(a[7]+a[13]); H=105*(a[6]+a[14]);
 
         // phi derivative
         Bp=-3*(ap[2]+ap[4]); Cp=3*(ap[1]+ap[5]); Ep=-2.5*(ap[9]+ap[11]);
         Fp=7.5*(ap[8]+ap[12]); Gp=-105*(ap[7]+ap[13]); Hp=105*(ap[6]+ap[14]);
 
         // 2phi derivative
         Bs=-B;    Cs=-4*C;  Es=-E;
         Fs=-4*F;  Gs=-9*G;  Hs=-16*H;
 
         // solve cubic for tan(theta)
         std::vector<double> tanTheta = SolveCubic(Hp+Cp-Fp, Gp+Bp-3*Ep, 6*Fp+Cp, Bp+4*Ep);
 
         highRes = false;
         dPhi = phi_step;
 
         //for each real cubic solution for tan(theta)
         for (int n=0; n<tanTheta.size(); n++)
         {
             double tmp = atan(tanTheta[n]); // arcus tangens of root (theta -pi/2..pi/2)
             double theta = floor(tmp/M_PI); // project theta to 0..pi ...
             theta = tmp - theta*M_PI;       // ... as the modulo of the division atan(tth[n])/M_PI
 
             sn = sin(2*theta); cs = cos(2*theta);
             tmp = ODF_dtheta(sn, cs, A, B, C, D, E, F, G, H);
 
             if (fabs(tmp) < thr) // second condition for maximum is true (theta derivative < eps)
             {
                 //Compute the Hessian
                 vnl_matrix_fixed< double, 2, 2 > hessian;
                 hessian(0,0) = ODF_dtheta2(sn, cs, A, B, C, D, E, F, G, H);
                 hessian(0,1) = ODF_dtheta(sn, cs, 0, Bp, Cp, 0, Ep, Fp, Gp, Hp);
                 hessian(1,0) = hessian(0,1);
                 hessian(1,1) = ODF_dphi2(sn, cs, 0, Bs, Cs, 0, Es, Fs, Gs, Hs);
 
                 double det = vnl_det(hessian);  // determinant
                 double tr = vnl_trace(hessian); // trace
 
                 highRes = true; // we are close to a maximum, so turn on high resolution 1D exhaustive search
                 if (det>=0 && tr<=0) // check if we really have a local maximum
                 {
                     vnl_vector_fixed< double, 2 > peak;
                     peak[0] = theta;
                     peak[1] = phi;
                     m_CandidatePeaks.push_back(peak);
                 }
             }
 
             if (adaptiveStepwidth) // calculate adaptive step width
             {
                 double t2=tanTheta[n]*tanTheta[n];  double t3=t2*tanTheta[n]; double t4=t3*tanTheta[n];
                 double const_step=phi_step*(1+t2)/sqrt(t2+t4+pow((((Hs+Cs-Fs)*t3+(Gs+Bs-3*Es)*t2+(6*Fs+Cs)*tanTheta[n]+(Bs+4*Es))/(3*(Hp+Cp-Fp)*t2+2*(Gp+Bp-3*Ep)*tanTheta[n]+(6*Fp+Cp))),2.0));
                 if (const_step<dPhi)
                     dPhi=const_step;
             }
         }
 
         // update phi
         if (highRes)
             phi=phi+dPhi*0.5;
         else
             phi=phi+dPhi;
     }
     }
 }
 
 template< class TOdfPixelType >
 std::vector< vnl_vector_fixed< double, 3 > > OdfMaximaExtractionFilter< TOdfPixelType >
 ::ClusterPeaks(const CoefficientPixelType& shCoeff)
 {
     const double distThres = 0.4;
     int npeaks = 0, nMin = 0;
     double dMin, dPos, dNeg, d;
     Vector3D u;
     vector< Vector3D > v;
 
     // initialize container for vector clusters
     std::vector < std::vector< Vector3D > > clusters;
     clusters.resize(m_CandidatePeaks.size());
 
     for (int i=0; i<m_CandidatePeaks.size(); i++)
     {
         // calculate cartesian representation of peak
         u[0] = sin(m_CandidatePeaks[i](0))*cos(m_CandidatePeaks[i](1));
         u[1] = sin(m_CandidatePeaks[i](0))*sin(m_CandidatePeaks[i](1));
         u[2] = cos(m_CandidatePeaks[i](0));
 
         dMin = itk::NumericTraits<double>::max();
         for (int n=0; n<npeaks; n++) //for each other maximum v already visited
         {
             // euclidean distance from u/-u to other clusters
             dPos = vnl_vector_ssd(v[n],u);
             dNeg = vnl_vector_ssd(v[n],-u);
             d = std::min(dPos,dNeg);
 
             if ( d<dMin )
             {
                 dMin = d; // adjust minimum
                 nMin = n; // store its index
                 if ( dNeg<dPos ) // flip u if neccesary
                     u=-u;
             }
         }
         if ( dMin<distThres ) // if u is very close to any other maximum v
         {
             clusters[nMin].push_back(u);  //store it with all other vectors that are close to v vector (with index nMin)
         }
         else // otherwise store u as output peak
         {
             v.push_back(u);
             npeaks++;
         }
     }
 
     // calculate mean vector of each cluster
     for (int i=0; i<m_CandidatePeaks.size(); i++)
         if ( !clusters[i].empty() )
         {
             v[i].fill(0.0);
             for (int vc=0; vc<clusters[i].size(); vc++)
                 v[i]=v[i]+clusters[i][vc];
             v[i].normalize();
         }
 
 
     if (npeaks!=0)
     {
         // check the ODF amplitudes at each candidate peak
         vnl_matrix< double > shBasis, sphCoords;
 
         Cart2Sph(v, sphCoords);                 // convert candidate peaks to spherical angles
         shBasis = CalcShBasis(sphCoords, 4);  // evaluate spherical harmonics at each peak
         vnl_vector<double> odfVals(npeaks);
         odfVals.fill(0.0);
         double maxVal = itk::NumericTraits<double>::NonpositiveMin();
         int maxPos;
         for (int i=0; i<npeaks; i++) //compute the ODF value at each peak
         {
             for (int j=0; j<15; j++)
                 odfVals(i) += shCoeff[j]*shBasis(i,j);
 
             if ( odfVals(i)>maxVal )
             {
                 maxVal = odfVals(i);
                 maxPos = i;
             }
         }
         v.clear();
         vector< double > restVals;
         for (int i=0; i<npeaks; i++) // keep only peaks with high enough amplitude and convert back to cartesian coordinates
             if ( odfVals(i)>=m_PeakThreshold*maxVal )
             {
                 u[0] = odfVals(i)*cos(sphCoords(i,1))*sin(sphCoords(i,0));
                 u[1] = odfVals(i)*sin(sphCoords(i,1))*sin(sphCoords(i,0));
                 u[2] = odfVals(i)*cos(sphCoords(i,0));
                 restVals.push_back(odfVals(i));
                 v.push_back(u);
             }
         npeaks = v.size();
 
         if (npeaks>m_MaxNumPeaks) // if still too many peaks, keep only the m_MaxNumPeaks with maximum value
         {
             vector< Vector3D > v2;
             for (int i=0; i<m_MaxNumPeaks; i++)
             {
                 maxVal = itk::NumericTraits<double>::NonpositiveMin();  //Get the maximum ODF peak value and the corresponding peak index
                 for (int i=0; i<npeaks; i++)
                     if ( restVals[i]>maxVal )
                     {
                         maxVal = restVals[i];
                         maxPos = i;
                     }
 
                 v2.push_back(v[maxPos]);
                 restVals[maxPos] = 0;               //zero that entry in order to find the next maximum
             }
             return v2;
         }
     }
     return v;
 }
 
 // convert cartesian to spherical coordinates
 template< class TOdfPixelType >
 void OdfMaximaExtractionFilter< TOdfPixelType >
 ::Cart2Sph(const std::vector< Vector3D >& dir, vnl_matrix<double>& sphCoords)
 {
     sphCoords.set_size(dir.size(), 2);
 
     for (int i=0; i<dir.size(); i++)
     {
         double mag = dir[i].magnitude();
 
         if( mag<mitk::eps )
         {
             sphCoords(i,0) = M_PI/2; // theta
             sphCoords(i,1) = M_PI/2; // phi
         }
         else
         {
             sphCoords(i,0) = acos(dir[i](2)/mag); // theta
             sphCoords(i,1) = atan2(dir[i](1), dir[i](0)); // phi
         }
     }
 }
 
 // generate spherical harmonic values of the desired order for each input direction
 template< class TOdfPixelType >
 vnl_matrix<double> OdfMaximaExtractionFilter< TOdfPixelType >
 ::CalcShBasis(vnl_matrix<double>& sphCoords, const int& shOrder)
 {
     int R = (shOrder+1)*(shOrder+2)/2;
     int M = sphCoords.rows();
     int j, m; double mag, plm;
     vnl_matrix<double> shBasis;
     shBasis.set_size(M,R);
 
     for (int p=0; p<M; p++)
     {
         j=0;
         for (int l=0; l<=shOrder; l=l+2)
             for (m=-l; m<=l; m++)
             {
                 plm = legendre_p<double>(l,abs(m),cos(sphCoords(p,0)));
                 mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
 
                 if (m<0)
                     shBasis(p,j) = sqrt(2.0)*mag*cos(fabs((double)m)*sphCoords(p,1));
                 else if (m==0)
                     shBasis(p,j) = mag;
                 else
                     shBasis(p,j) = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*sphCoords(p,1));
                 j++;
             }
     }
     return shBasis;
 }
 
 template< class TOdfPixelType >
 void OdfMaximaExtractionFilter< TOdfPixelType >
 ::GenerateData()
 {
     if (!ReconstructQballImage())
         return;
 
     std::cout << "Starting maxima extraction\n";
 
     switch (m_NormalizationMethod)
     {
     case NO_NORM:
         std::cout << "NO_NORM\n";
         break;
     case SINGLE_VEC_NORM:
         std::cout << "SINGLE_VEC_NORM\n";
         break;
     case MAX_VEC_NORM:
         std::cout << "MAX_VEC_NORM\n";
         break;
     }
 
     typedef ImageRegionConstIterator< CoefficientImageType > InputIteratorType;
 
 
     InputIteratorType git(m_ShCoeffImage, m_ShCoeffImage->GetLargestPossibleRegion() );
 
     itk::Vector<double,3> spacing = m_ShCoeffImage->GetSpacing();
     double minSpacing = spacing[0];
     if (spacing[1]<minSpacing)
         minSpacing = spacing[1];
     if (spacing[2]<minSpacing)
         minSpacing = spacing[2];
 
     mitk::Point3D origin = m_ShCoeffImage->GetOrigin();
     itk::Matrix<double, 3, 3> direction = m_ShCoeffImage->GetDirection();
     ImageRegion<3> imageRegion = m_ShCoeffImage->GetLargestPossibleRegion();
 
     // initialize num directions image
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( spacing );
     m_NumDirectionsImage->SetOrigin( origin );
     m_NumDirectionsImage->SetDirection( direction );
     m_NumDirectionsImage->SetRegions( imageRegion );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     m_DirectionImageContainer = ItkDirectionImageContainer::New();
     for (int i=0; i<m_MaxNumPeaks; i++)
     {
         itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
         ItkDirectionImage::Pointer img = ItkDirectionImage::New();
         img->SetSpacing( spacing );
         img->SetOrigin( origin );
         img->SetDirection( direction );
         img->SetRegions( imageRegion );
         img->Allocate();
         img->FillBuffer(nullVec);
         m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
     }
 
     if (m_MaskImage.IsNull())
     {
         m_MaskImage = ItkUcharImgType::New();
         m_MaskImage->SetSpacing( spacing );
         m_MaskImage->SetOrigin( origin );
         m_MaskImage->SetDirection( direction );
         m_MaskImage->SetRegions( imageRegion );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
 
     itk::ImageRegionIterator<ItkUcharImgType> dirIt(m_NumDirectionsImage, m_NumDirectionsImage->GetLargestPossibleRegion());
     itk::ImageRegionIterator<ItkUcharImgType> maskIt(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
 
     int maxProgress = m_MaskImage->GetLargestPossibleRegion().GetSize()[0]*m_MaskImage->GetLargestPossibleRegion().GetSize()[1]*m_MaskImage->GetLargestPossibleRegion().GetSize()[2];
 
     boost::progress_display disp(maxProgress);
 
     git.GoToBegin();
     while( !git.IsAtEnd() )
     {
         ++disp;
         if (maskIt.Value()<=0)
         {
             ++git;
             ++dirIt;
             ++maskIt;
             continue;
         }
 
         CoefficientPixelType c = git.Get();
         FindCandidatePeaks(c);
         std::vector< Vector3D > directions = ClusterPeaks(c);
 
         typename CoefficientImageType::IndexType index = git.GetIndex();
 
         float max = 0.0;
         for (int i=0; i<directions.size(); i++)
             if (directions.at(i).magnitude()>max)
                 max = directions.at(i).magnitude();
         if (max<0.0001)
             max = 1.0;
 
         for (int i=0; i<directions.size(); i++)
         {
             ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
             itk::Vector< float, 3 > pixel;
             vnl_vector<double> dir = directions.at(i);
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             itk::ContinuousIndex<double, 3> center;
             center[0] = index[0];
             center[1] = index[1];
             center[2] = index[2];
             itk::Point<double> worldCenter;
             m_ShCoeffImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
 
             switch (m_NormalizationMethod)
             {
             case NO_NORM:
                 break;
             case SINGLE_VEC_NORM:
                 dir.normalize();
                 break;
             case MAX_VEC_NORM:
                 dir /= max;
                 break;
             }
 
             dir = m_MaskImage->GetDirection()*dir;
             pixel.SetElement(0, dir[0]);
             pixel.SetElement(1, dir[1]);
             pixel.SetElement(2, dir[2]);
             img->SetPixel(index, pixel);
 
             itk::Point<double> worldStart;
             worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
             worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
             worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
             vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             itk::Point<double> worldEnd;
             worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
             worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
             worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
             id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             m_VtkCellArray->InsertNextCell(container);
         }
 
         dirIt.Set(directions.size());
 
         ++git;
         ++dirIt;
         ++maskIt;
     }
 
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
     m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
     std::cout << "Maxima extraction finished\n";
 }
 }
 
 #endif // __itkOdfMaximaExtractionFilter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkShCoefficientImageImporter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkShCoefficientImageImporter.cpp
index 0a79d15313..84599b9167 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkShCoefficientImageImporter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkShCoefficientImageImporter.cpp
@@ -1,195 +1,193 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef __itkShCoefficientImageImporter_cpp
 #define __itkShCoefficientImageImporter_cpp
 
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "itkShCoefficientImageImporter.h"
 #include <itkImageRegionIterator.h>
-#ifndef Q_MOC_RUN
-#  include <boost/math/special_functions.hpp>
-#endif
+#include <boost/math/special_functions.hpp>
 
 using namespace boost::math;
 
 namespace itk {
 
 template< class PixelType, int ShOrder >
 ShCoefficientImageImporter< PixelType, ShOrder >::ShCoefficientImageImporter()
     : m_Toolkit(FSL)
 {
     m_ShBasis.set_size(QBALL_ODFSIZE, (ShOrder+1)*(ShOrder+2)/2);
 }
 
 template< class PixelType, int ShOrder >
 void ShCoefficientImageImporter< PixelType, ShOrder >
 ::GenerateData()
 {
     CalcShBasis();
     if (m_InputImage.IsNull())
         return;
 
     Vector<float, 4> spacing4 = m_InputImage->GetSpacing();
     Point<float, 4> origin4 = m_InputImage->GetOrigin();
     Matrix<double, 4, 4> direction4 = m_InputImage->GetDirection();
     ImageRegion<4> imageRegion4 = m_InputImage->GetLargestPossibleRegion();
 
     Vector<double, 3> spacing3;
     Point<float, 3> origin3;
     Matrix<double, 3, 3> direction3;
     ImageRegion<3> imageRegion3;
 
     spacing3[0] = spacing4[0]; spacing3[1] = spacing4[1]; spacing3[2] = spacing4[2];
     origin3[0] = origin4[0]; origin3[1] = origin4[1]; origin3[2] = origin4[2];
     for (int r=0; r<3; r++)
         for (int c=0; c<3; c++)
             direction3[r][c] = direction4[r][c];
     imageRegion3.SetSize(0, imageRegion4.GetSize()[0]);
     imageRegion3.SetSize(1, imageRegion4.GetSize()[1]);
     imageRegion3.SetSize(2, imageRegion4.GetSize()[2]);
 
     m_QballImage = QballImageType::New();
     m_QballImage->SetSpacing( spacing3 );
     m_QballImage->SetOrigin( origin3 );
     m_QballImage->SetDirection( direction3 );
     m_QballImage->SetRegions( imageRegion3 );
     m_QballImage->Allocate();
     Vector< PixelType, QBALL_ODFSIZE > nullVec1; nullVec1.Fill(0.0);
     m_QballImage->FillBuffer(nullVec1);
 
     m_CoefficientImage = CoefficientImageType::New();
     m_CoefficientImage->SetSpacing( spacing3 );
     m_CoefficientImage->SetOrigin( origin3 );
     m_CoefficientImage->SetDirection( direction3 );
     m_CoefficientImage->SetRegions( imageRegion3 );
     m_CoefficientImage->Allocate();
     Vector< PixelType, (ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder > nullVec2; nullVec2.Fill(0.0);
     m_CoefficientImage->FillBuffer(nullVec2);
 
     typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
     int x = imageRegion4.GetSize(0);
     int y = imageRegion4.GetSize(1);
     int z = imageRegion4.GetSize(2);
     int numCoeffs = imageRegion4.GetSize(3);
 
     for (int a=0; a<x; a++)
         for (int b=0; b<y; b++)
             for (int c=0; c<z; c++)
             {
                 vnl_matrix<double> coeffs((ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder,1);
 
                 typename InputImageType::IndexType index;
                 index.SetElement(0,a);
                 index.SetElement(1,b);
                 index.SetElement(2,c);
                 typename CoefficientImageType::PixelType pix;
                 for (int d=0; d<numCoeffs; d++)
                 {
                     index.SetElement(3,d);
                     pix[d] = m_InputImage->GetPixel(index);
                     coeffs[d][0] = pix[d];
                 }
                 typename CoefficientImageType::IndexType index2;
                 index2.SetElement(0,a);
                 index2.SetElement(1,b);
                 index2.SetElement(2,c);
                 m_CoefficientImage->SetPixel(index2, pix);
 
                 typename QballImageType::PixelType pix2;
                 vnl_matrix<double> odf = m_ShBasis*coeffs;
                 for (int d=0; d<QBALL_ODFSIZE; d++)
                     pix2[d] = odf(d,0)*M_PI*4/QBALL_ODFSIZE;
 
                 m_QballImage->SetPixel(index2,pix2);
             }
 }
 
 // generate spherical harmonic values of the desired order for each input direction
 template< class PixelType, int ShOrder >
 void ShCoefficientImageImporter< PixelType, ShOrder >
 ::CalcShBasis()
 {
     vnl_matrix_fixed<double, 2, QBALL_ODFSIZE> sphCoords = GetSphericalOdfDirections();
     int j, m; double mag, plm;
 
     for (int p=0; p<QBALL_ODFSIZE; p++)
     {
         j=0;
         for (int l=0; l<=ShOrder; l=l+2)
             for (m=-l; m<=l; m++)
             {
                 switch (m_Toolkit)
                 {
                 case FSL:
                     plm = legendre_p<double>(l,abs(m),cos(sphCoords(0,p)));
                     mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
                     if (m<0)
                         m_ShBasis(p,j) = sqrt(2.0)*mag*cos(-m*sphCoords(1,p));
                     else if (m==0)
                         m_ShBasis(p,j) = mag;
                     else
                         m_ShBasis(p,j) = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*sphCoords(1,p));
                     break;
                 case MRTRIX:
                     plm = legendre_p<double>(l,abs(m),-cos(sphCoords(0,p)));
                     mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
                     if (m>0)
                         m_ShBasis(p,j) = mag*cos(m*sphCoords(1,p));
                     else if (m==0)
                         m_ShBasis(p,j) = mag;
                     else
                         m_ShBasis(p,j) = mag*sin(-m*sphCoords(1,p));
                     break;
                 }
 
                 j++;
             }
     }
 }
 
 // convert cartesian to spherical coordinates
 template< class PixelType, int ShOrder >
 vnl_matrix_fixed<double, 2, QBALL_ODFSIZE> ShCoefficientImageImporter< PixelType, ShOrder >
 ::GetSphericalOdfDirections()
 {
     itk::OrientationDistributionFunction< PixelType, QBALL_ODFSIZE > odf;
     vnl_matrix_fixed<double, 3, QBALL_ODFSIZE>* dir = odf.GetDirections();
     vnl_matrix_fixed<double, 2, QBALL_ODFSIZE> sphCoords;
 
     for (int i=0; i<QBALL_ODFSIZE; i++)
     {
         double mag = dir->get_column(i).magnitude();
 
         if( mag<mitk::eps )
         {
             sphCoords(0,i) = M_PI/2; // theta
             sphCoords(1,i) = M_PI/2; // phi
         }
         else
         {
             sphCoords(0,i) = acos(dir->get(2,i)/mag); // theta
             sphCoords(1,i) = atan2(dir->get(1,i), dir->get(0,i)); // phi
         }
     }
     return sphCoords;
 }
 
 }
 
 #endif // __itkShCoefficientImageImporter_cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.cpp b/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.cpp
index 8521df8925..e7fe6c5b5c 100644
--- a/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/mitkDiffusionFunctionCollection.cpp
@@ -1,252 +1,250 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkDiffusionFunctionCollection.h"
 #include <math.h>
 #include "mitkVector.h"
 
 // for Windows
 #ifndef M_PI
 #define M_PI  3.14159265358979323846
 #endif
 
 // Namespace ::SH
-#ifndef Q_MOC_RUN
-#  include <boost/math/special_functions/legendre.hpp>
-#  include <boost/math/special_functions/spherical_harmonic.hpp>
-#  include <boost/version.hpp>
-#endif
+#include <boost/math/special_functions/legendre.hpp>
+#include <boost/math/special_functions/spherical_harmonic.hpp>
+#include <boost/version.hpp>
 
 
 // Namespace ::Gradients
 #include "itkVectorContainer.h"
 #include "vnl/vnl_vector.h"
 
 //------------------------- SH-function ------------------------------------
 
 double mitk::sh::factorial(int number) {
   if(number <= 1) return 1;
   double result = 1.0;
   for(int i=1; i<=number; i++)
     result *= i;
   return result;
 }
 
 void mitk::sh::Cart2Sph(double x, double y, double z, double *cart)
 {
   double phi, th, rad;
   rad = sqrt(x*x+y*y+z*z);
   if( rad < mitk::eps )
   {
     th = M_PI/2;
     phi = M_PI/2;
   }
   else
   {
     th = acos(z/rad);
     phi = atan2(y, x);
   }
   cart[0] = phi;
   cart[1] = th;
   cart[2] = rad;
 }
 
 double mitk::sh::legendre0(int l)
 {
   if( l%2 != 0 )
   {
     return 0;
   }
   else
   {
     double prod1 = 1.0;
     for(int i=1;i<l;i+=2) prod1 *= i;
     double prod2 = 1.0;
     for(int i=2;i<=l;i+=2) prod2 *= i;
     return pow(-1.0,l/2.0)*(prod1/prod2);
   }
 }
 
 
 double mitk::sh::Yj(int m, int l, double theta, double phi)
 {
   if (m<0)
     return sqrt(2.0)*::boost::math::spherical_harmonic_r(l, -m, theta, phi);
   else if (m==0)
     return ::boost::math::spherical_harmonic_r(l, m, theta, phi);
   else
     return pow(-1.0,m)*sqrt(2.0)*::boost::math::spherical_harmonic_i(l, m, theta, phi);
 
   return 0;
 }
 
 
 
 //------------------------- gradients-function ------------------------------------
 
 std::vector<unsigned int> mitk::gradients::GetAllUniqueDirections(const BValueMap & refBValueMap, GradientDirectionContainerType *refGradientsContainer )
 {
 
   IndiciesVector directioncontainer;
   BValueMap::const_iterator mapIterator = refBValueMap.begin();
 
   if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)
     mapIterator++; //skip bzero Values
 
   for( ; mapIterator != refBValueMap.end(); mapIterator++){
 
     IndiciesVector currentShell = mapIterator->second;
 
     while(currentShell.size()>0)
     {
       unsigned int wntIndex = currentShell.back();
       currentShell.pop_back();
 
       IndiciesVector::iterator containerIt = directioncontainer.begin();
       bool directionExist = false;
       while(containerIt != directioncontainer.end())
       {
         if (fabs(dot(refGradientsContainer->ElementAt(*containerIt), refGradientsContainer->ElementAt(wntIndex)))  > 0.9998)
         {
           directionExist = true;
           break;
         }
         containerIt++;
       }
       if(!directionExist)
       {
         directioncontainer.push_back(wntIndex);
       }
     }
   }
 
   return directioncontainer;
 }
 
 
 bool mitk::gradients::CheckForDifferingShellDirections(const BValueMap & refBValueMap, GradientDirectionContainerType::ConstPointer refGradientsContainer)
 {
   BValueMap::const_iterator mapIterator = refBValueMap.begin();
 
   if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)
     mapIterator++; //skip bzero Values
 
   for( ; mapIterator != refBValueMap.end(); mapIterator++){
 
     BValueMap::const_iterator mapIterator_2 = refBValueMap.begin();
     if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)
       mapIterator_2++; //skip bzero Values
 
     for( ; mapIterator_2 != refBValueMap.end(); mapIterator_2++){
 
       if(mapIterator_2 == mapIterator) continue;
 
       IndiciesVector currentShell = mapIterator->second;
       IndiciesVector testShell = mapIterator_2->second;
       for (unsigned int i = 0; i< currentShell.size(); i++)
         if (fabs(dot(refGradientsContainer->ElementAt(currentShell[i]), refGradientsContainer->ElementAt(testShell[i])))  <= 0.9998) { return true; }
 
     }
   }
   return false;
 }
 
 
 template<typename type>
 double mitk::gradients::dot (vnl_vector_fixed< type ,3> const& v1, vnl_vector_fixed< type ,3 > const& v2 )
 {
   double result = (v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]) / (v1.two_norm() * v2.two_norm());
   return result ;
 }
 
 vnl_matrix<double> mitk::gradients::ComputeSphericalFromCartesian(const IndiciesVector & refShell, const GradientDirectionContainerType * refGradientsContainer)
 {
 
   vnl_matrix<double> Q(3, refShell.size());
 
   for(unsigned int i = 0; i < refShell.size(); i++)
   {
     GradientDirectionType dir = refGradientsContainer->ElementAt(refShell[i]);
     double x = dir.normalize().get(0);
     double y = dir.normalize().get(1);
     double z = dir.normalize().get(2);
     double cart[3];
     mitk::sh::Cart2Sph(x,y,z,cart);
     Q(0,i) = cart[0];
     Q(1,i) = cart[1];
     Q(2,i) = cart[2];
   }
   return Q;
 }
 
 vnl_matrix<double> mitk::gradients::ComputeSphericalHarmonicsBasis(const vnl_matrix<double> & QBallReference, const unsigned int & LOrder)
 {
   vnl_matrix<double> SHBasisOutput(QBallReference.cols(), (LOrder+1)*(LOrder+2)*0.5);
   for(unsigned int i=0; i< SHBasisOutput.rows(); i++)
     for(int k = 0; k <= LOrder; k += 2)
       for(int m =- k; m <= k; m++)
       {
         int j = ( k * k + k + 2 ) / 2 + m - 1;
         double phi = QBallReference(0,i);
         double th = QBallReference(1,i);
         SHBasisOutput(i,j) = mitk::sh::Yj(m,k,th,phi);
       }
   return SHBasisOutput;
 }
 
 mitk::gradients::GradientDirectionContainerType::Pointer mitk::gradients::CreateNormalizedUniqueGradientDirectionContainer(const mitk::gradients::BValueMap & bValueMap,
     const GradientDirectionContainerType *origninalGradentcontainer)
 {
   mitk::gradients::GradientDirectionContainerType::Pointer directioncontainer = mitk::gradients::GradientDirectionContainerType::New();
   BValueMap::const_iterator mapIterator = bValueMap.begin();
 
   if(bValueMap.find(0) != bValueMap.end() && bValueMap.size() > 1){
     mapIterator++; //skip bzero Values
     vnl_vector_fixed<double, 3> vec;
     vec.fill(0.0);
     directioncontainer->push_back(vec);
   }
 
   for( ; mapIterator != bValueMap.end(); mapIterator++){
 
     IndiciesVector currentShell = mapIterator->second;
 
     while(currentShell.size()>0)
     {
       unsigned int wntIndex = currentShell.back();
       currentShell.pop_back();
 
       mitk::gradients::GradientDirectionContainerType::Iterator containerIt = directioncontainer->Begin();
       bool directionExist = false;
       while(containerIt != directioncontainer->End())
       {
         if (fabs(dot(containerIt.Value(), origninalGradentcontainer->ElementAt(wntIndex)))  > 0.9998)
         {
           directionExist = true;
           break;
         }
         containerIt++;
       }
       if(!directionExist)
       {
         GradientDirectionType dir(origninalGradentcontainer->ElementAt(wntIndex));
         directioncontainer->push_back(dir.normalize());
       }
     }
   }
 
   return directioncontainer;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkAddArtifactsToDwiImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkAddArtifactsToDwiImageFilter.cpp
index 65b6515529..c9d5bb5113 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkAddArtifactsToDwiImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkAddArtifactsToDwiImageFilter.cpp
@@ -1,268 +1,266 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef __itkAddArtifactsToDwiImageFilter_txx
 #define __itkAddArtifactsToDwiImageFilter_txx
 
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "itkAddArtifactsToDwiImageFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#endif
+#include <boost/progress.hpp>
 #include <itkImageDuplicator.h>
 #include <itkResampleDwiImageFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 namespace itk {
 
 template< class TPixelType >
 AddArtifactsToDwiImageFilter< TPixelType >
 ::AddArtifactsToDwiImageFilter()
     : m_NoiseModel(NULL)
     , m_FrequencyMap(NULL)
     , m_kOffset(0)
     , m_tLine(1)
     , m_EddyGradientStrength(0.001)
     , m_SimulateEddyCurrents(false)
     , m_TE(100)
     , m_Upsampling(1)
 {
     this->SetNumberOfRequiredInputs( 1 );
 }
 
 
 template< class TPixelType >
 AddArtifactsToDwiImageFilter< TPixelType >::ComplexSliceType::Pointer AddArtifactsToDwiImageFilter< TPixelType >::RearrangeSlice(ComplexSliceType::Pointer slice)
 {
     ImageRegion<2> region = slice->GetLargestPossibleRegion();
     typename ComplexSliceType::Pointer rearrangedSlice = ComplexSliceType::New();
     rearrangedSlice->SetLargestPossibleRegion( region );
     rearrangedSlice->SetBufferedRegion( region );
     rearrangedSlice->SetRequestedRegion( region );
     rearrangedSlice->Allocate();
 
     int xHalf = region.GetSize(0)/2;
     int yHalf = region.GetSize(1)/2;
 
     for (int y=0; y<region.GetSize(1); y++)
         for (int x=0; x<region.GetSize(0); x++)
         {
             typename SliceType::IndexType idx;
             idx[0]=x; idx[1]=y;
             vcl_complex< SliceType::PixelType > pix = slice->GetPixel(idx);
 
             if( idx[0] <  xHalf )
                 idx[0] = idx[0] + xHalf;
             else
                 idx[0] = idx[0] - xHalf;
 
             if( idx[1] <  yHalf )
                 idx[1] = idx[1] + yHalf;
             else
                 idx[1] = idx[1] - yHalf;
 
             rearrangedSlice->SetPixel(idx, pix);
         }
 
     return rearrangedSlice;
 }
 
 template< class TPixelType >
 void AddArtifactsToDwiImageFilter< TPixelType >
 ::GenerateData()
 {
     typename DiffusionImageType::Pointer inputImage  = static_cast< DiffusionImageType * >( this->ProcessObject::GetInput(0) );
     itk::ImageRegion<3> inputRegion = inputImage->GetLargestPossibleRegion();
 
     typename itk::ImageDuplicator<DiffusionImageType>::Pointer duplicator = itk::ImageDuplicator<DiffusionImageType>::New();
     duplicator->SetInputImage( inputImage );
     duplicator->Update();
     typename DiffusionImageType::Pointer outputImage = duplicator->GetOutput();
 
     // is input slize size even?
     int x=inputRegion.GetSize(0); int y=inputRegion.GetSize(1);
     if ( x%2 == 1 )
         x += 1;
     if ( y%2 == 1 )
         y += 1;
 
     // create slice object
     typename SliceType::Pointer slice = SliceType::New();
     ImageRegion<2> sliceRegion;
     sliceRegion.SetSize(0, x);
     sliceRegion.SetSize(1, y);
     slice->SetLargestPossibleRegion( sliceRegion );
     slice->SetBufferedRegion( sliceRegion );
     slice->SetRequestedRegion( sliceRegion );
     slice->Allocate();
     slice->FillBuffer(0.0);
 
     ImageRegion<2> upsampledSliceRegion;
     if (m_Upsampling>1.00001)
     {
         upsampledSliceRegion.SetSize(0, x*m_Upsampling);
         upsampledSliceRegion.SetSize(1, y*m_Upsampling);
     }
 
     // frequency map slice
     typename SliceType::Pointer fMap = NULL;
     if (m_FrequencyMap.IsNotNull())
     {
         fMap = SliceType::New();
         fMap->SetLargestPossibleRegion( sliceRegion );
         fMap->SetBufferedRegion( sliceRegion );
         fMap->SetRequestedRegion( sliceRegion );
         fMap->Allocate();
         fMap->FillBuffer(0.0);
     }
 
     if ( m_FrequencyMap.IsNotNull() || m_kOffset>0.0 || m_Upsampling>1.00001 || m_SimulateEddyCurrents)
     {
         MatrixType transform = inputImage->GetDirection();
         for (int i=0; i<3; i++)
             for (int j=0; j<3; j++)
                     transform[i][j] *= inputImage->GetSpacing()[j];
 
         MITK_INFO << "Adjusting complex signal";
         MITK_INFO << "line readout time: " << m_tLine;
         MITK_INFO << "line offset: " << m_kOffset;
         if (m_FrequencyMap.IsNotNull())
             MITK_INFO << "frequency map is set";
         else
             MITK_INFO << "no frequency map set";
         if (m_Upsampling>1.00001)
             MITK_INFO << "Gibbs ringing enabled";
         else
             MITK_INFO << "Gibbs ringing disabled";
 
         if (m_SimulateEddyCurrents)
             MITK_INFO << "Simulating eddy currents";
 
         boost::progress_display disp(inputImage->GetVectorLength()*inputRegion.GetSize(2));
         for (int g=0; g<inputImage->GetVectorLength(); g++)
             for (int z=0; z<inputRegion.GetSize(2); z++)
             {
                 std::vector< SliceType::Pointer > compartmentSlices;
                 // extract slice from channel g
                 for (int y=0; y<sliceRegion.GetSize(1); y++)
                     for (int x=0; x<sliceRegion.GetSize(0); x++)
                     {
                         typename SliceType::IndexType index2D;
                         index2D[0]=x; index2D[1]=y;
                         typename DiffusionImageType::IndexType index3D;
                         index3D[0]=x; index3D[1]=y; index3D[2]=z;
 
                         SliceType::PixelType pix2D = (SliceType::PixelType)inputImage->GetPixel(index3D)[g];
                         slice->SetPixel(index2D, pix2D);
 
                         if (fMap.IsNotNull())
                             fMap->SetPixel(index2D, m_FrequencyMap->GetPixel(index3D));
                     }
 
                 if (m_Upsampling>1.00001)
                 {
                     itk::ResampleImageFilter<SliceType, SliceType>::Pointer resampler = itk::ResampleImageFilter<SliceType, SliceType>::New();
                     resampler->SetInput(slice);
                     resampler->SetOutputParametersFromImage(slice);
                     resampler->SetSize(upsampledSliceRegion.GetSize());
                     resampler->SetOutputSpacing(slice->GetSpacing()/m_Upsampling);
                     resampler->Update();
                     typename SliceType::Pointer upslice = resampler->GetOutput();
                     compartmentSlices.push_back(upslice);
                 }
                 else
                     compartmentSlices.push_back(slice);
 
                 // fourier transform slice
                 typename ComplexSliceType::Pointer fSlice;
 
                 itk::Size<2> outSize; outSize.SetElement(0, x); outSize.SetElement(1, y);
                 typename itk::KspaceImageFilter< SliceType::PixelType >::Pointer idft = itk::KspaceImageFilter< SliceType::PixelType >::New();
                 idft->SetCompartmentImages(compartmentSlices);
                 idft->SetkOffset(m_kOffset);
                 idft->SettLine(m_tLine);
                 idft->SetSimulateRelaxation(false);
                 idft->SetFrequencyMap(fMap);
                 idft->SetDiffusionGradientDirection(m_GradientList.at(g));
                 idft->SetSimulateEddyCurrents(m_SimulateEddyCurrents);
                 idft->SetEddyGradientMagnitude(m_EddyGradientStrength);
                 idft->SetTE(m_TE);
                 idft->SetZ((double)z-(double)inputRegion.GetSize(2)/2.0);
                 idft->SetDirectionMatrix(transform);
                 idft->SetOutSize(outSize);
                 idft->Update();
                 fSlice = idft->GetOutput();
 
                 // inverse fourier transform slice
                 typename SliceType::Pointer newSlice;
                 typename itk::DftImageFilter< SliceType::PixelType >::Pointer dft = itk::DftImageFilter< SliceType::PixelType >::New();
                 dft->SetInput(fSlice);
                 dft->Update();
                 newSlice = dft->GetOutput();
 
                 // put slice back into channel g
                 for (y=0; y<inputRegion.GetSize(1); y++)
                     for (x=0; x<inputRegion.GetSize(0); x++)
                     {
                         typename DiffusionImageType::IndexType index3D;
                         index3D[0]=x; index3D[1]=y; index3D[2]=z;
                         typename DiffusionImageType::PixelType pix3D = outputImage->GetPixel(index3D);
                         typename SliceType::IndexType index2D;
                         index2D[0]=x; index2D[1]=y;
 
                         double signal = newSlice->GetPixel(index2D);
                         if (signal>0)
                             signal = floor(signal+0.5);
                         else
                             signal = ceil(signal-0.5);
 
                         pix3D[g] = signal;
                         outputImage->SetPixel(index3D, pix3D);
                     }
 
                 ++disp;
             }
     }
 
     if (m_NoiseModel!=NULL)
     {
         ImageRegionIterator<DiffusionImageType> it1 (outputImage, inputRegion);
         boost::progress_display disp2(inputRegion.GetNumberOfPixels());
         while(!it1.IsAtEnd())
         {
             ++disp2;
 
             typename DiffusionImageType::PixelType signal = it1.Get();
             m_NoiseModel->AddNoise(signal);
             it1.Set(signal);
 
             ++it1;
         }
     }
 
     this->SetNthOutput(0, outputImage);
 }
 
 }
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateDirectionImagesFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateDirectionImagesFilter.cpp
index 837d576878..5fc4b37e71 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateDirectionImagesFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateDirectionImagesFilter.cpp
@@ -1,379 +1,377 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef __itkEvaluateDirectionImagesFilter_cpp
 #define __itkEvaluateDirectionImagesFilter_cpp
 
 #include "itkEvaluateDirectionImagesFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionIterator.h>
 #include <itkImageDuplicator.h>
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#endif
+#include <boost/progress.hpp>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 namespace itk {
 
 template< class PixelType >
 EvaluateDirectionImagesFilter< PixelType >
 ::EvaluateDirectionImagesFilter():
     m_ImageSet(NULL),
     m_ReferenceImageSet(NULL),
     m_IgnoreMissingDirections(false),
     m_Eps(0.0001)
 {
     this->SetNumberOfOutputs(2);
 }
 
 template< class PixelType >
 void EvaluateDirectionImagesFilter< PixelType >::GenerateData()
 {
     if (m_ImageSet.IsNull() || m_ReferenceImageSet.IsNull())
         return;
 
     DirectionImageContainerType::Pointer set1 = DirectionImageContainerType::New();
     DirectionImageContainerType::Pointer set2 = DirectionImageContainerType::New();
 
     for (int i=0; i<m_ImageSet->Size(); i++)
     {
         typename itk::ImageDuplicator< DirectionImageType >::Pointer duplicator = itk::ImageDuplicator< DirectionImageType >::New();
         duplicator->SetInputImage( m_ImageSet->GetElement(i) );
         duplicator->Update();
         set1->InsertElement(i, dynamic_cast<DirectionImageType*>(duplicator->GetOutput()));
     }
     for (int i=0; i<m_ReferenceImageSet->Size(); i++)
     {
         typename itk::ImageDuplicator< DirectionImageType >::Pointer duplicator = itk::ImageDuplicator< DirectionImageType >::New();
         duplicator->SetInputImage( m_ReferenceImageSet->GetElement(i) );
         duplicator->Update();
         set2->InsertElement(i, dynamic_cast<DirectionImageType*>(duplicator->GetOutput()));
     }
 
     m_ImageSet = set1;
     m_ReferenceImageSet = set2;
 
     // angular error image
     typename OutputImageType::Pointer outputImage = OutputImageType::New();
     outputImage->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
     outputImage->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
     outputImage->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
     outputImage->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
     outputImage->Allocate();
     outputImage->FillBuffer(0.0);
     this->SetNthOutput(0, outputImage);
 
     // length error image
     outputImage = OutputImageType::New();
     outputImage->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
     outputImage->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
     outputImage->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
     outputImage->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
     outputImage->Allocate();
     outputImage->FillBuffer(0.0);
     this->SetNthOutput(1, outputImage);
 
     if (m_MaskImage.IsNull())
     {
         m_MaskImage = UCharImageType::New();
         m_MaskImage->SetOrigin( outputImage->GetOrigin() );
         m_MaskImage->SetRegions( outputImage->GetLargestPossibleRegion() );
         m_MaskImage->SetSpacing( outputImage->GetSpacing() );
         m_MaskImage->SetDirection( outputImage->GetDirection() );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
 
     m_MeanAngularError = 0.0;
     m_MedianAngularError = 0;
     m_MaxAngularError = 0.0;
     m_MinAngularError = itk::NumericTraits<float>::max();
     m_VarAngularError = 0.0;
     m_AngularErrorVector.clear();
 
     m_MeanLengthError = 0.0;
     m_MedianLengthError = 0;
     m_MaxLengthError = 0.0;
     m_MinLengthError = itk::NumericTraits<float>::max();
     m_VarLengthError = 0.0;
     m_LengthErrorVector.clear();
 
     if (m_ImageSet.IsNull() || m_ReferenceImageSet.IsNull())
         return;
 
     outputImage = static_cast< OutputImageType* >(this->ProcessObject::GetOutput(0));
     typename OutputImageType::Pointer outputImage2 = static_cast< OutputImageType* >(this->ProcessObject::GetOutput(1));
 
     ImageRegionIterator< OutputImageType > oit(outputImage, outputImage->GetLargestPossibleRegion());
     ImageRegionIterator< OutputImageType > oit2(outputImage2, outputImage2->GetLargestPossibleRegion());
     ImageRegionIterator< UCharImageType > mit(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
 
     int numImages = m_ImageSet->Size();
     int numReferenceImages = m_ReferenceImageSet->Size();
 
     // fill missing directions with zeros
     if (numImages>numReferenceImages)
     {
         DirectionType zeroDir; zeroDir.Fill(0.0);
         for (int i=0; i<numImages-numReferenceImages; i++)
         {
             DirectionImageType::Pointer img = DirectionImageType::New();
             img->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
             img->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
             img->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
             img->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
             img->Allocate();
             img->FillBuffer(zeroDir);
             m_ReferenceImageSet->InsertElement(m_ReferenceImageSet->Size(), img);
         }
         numReferenceImages = numImages;
     }
     else if (numReferenceImages>numImages)
     {
         DirectionType zeroDir; zeroDir.Fill(0.0);
         for (int i=0; i<numReferenceImages-numImages; i++)
         {
             DirectionImageType::Pointer img = DirectionImageType::New();
             img->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
             img->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
             img->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
             img->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
             img->Allocate();
             img->FillBuffer(zeroDir);
             m_ImageSet->InsertElement(m_ImageSet->Size(), img);
         }
         numImages = numReferenceImages;
     }
     int numDirections = numReferenceImages;
 
     // matrix containing the angular error between the directions
     vnl_matrix< float > diffM; diffM.set_size(numDirections, numDirections);
 
     boost::progress_display disp(outputImage->GetLargestPossibleRegion().GetSize()[0]*outputImage->GetLargestPossibleRegion().GetSize()[1]*outputImage->GetLargestPossibleRegion().GetSize()[2]);
     while( !oit.IsAtEnd() )
     {
         ++disp;
         if( mit.Get()!=1 )
         {
             ++oit;
             ++oit2;
             ++mit;
             continue;
         }
         typename OutputImageType::IndexType index = oit.GetIndex();
 
         float maxAngularError = 1.0;
 
         diffM.fill(10); // initialize with invalid error value
 
         // get number of valid directions (length > 0)
         int numRefDirs = 0;
         int numTestDirs = 0;
         for (int i=0; i<numDirections; i++)
         {
             if (m_ReferenceImageSet->GetElement(i)->GetPixel(index).GetVnlVector().magnitude() > m_Eps )
                 numRefDirs++;
             if (m_ImageSet->GetElement(i)->GetPixel(index).GetVnlVector().magnitude() > m_Eps )
                 numTestDirs++;
         }
 
         // i: index of reference direction
         // j: index of test direction
         for (int i=0; i<numDirections; i++)     // for each reference direction
         {
             bool missingDir = false;
             vnl_vector_fixed< PixelType, 3 > refDir = m_ReferenceImageSet->GetElement(i)->GetPixel(index).GetVnlVector();
 
             if (i<numRefDirs)  // normalize if not null
                 refDir.normalize();
             else if (m_IgnoreMissingDirections)
                 continue;
             else
                 missingDir = true;
 
             for (int j=0; j<numDirections; j++)     // and each test direction
             {
                 vnl_vector_fixed< PixelType, 3 > testDir = m_ImageSet->GetElement(j)->GetPixel(index).GetVnlVector();
                 if (j<numTestDirs)  // normalize if not null
                     testDir.normalize();
                 else if (m_IgnoreMissingDirections || missingDir)
                     continue;
                 else
                     missingDir = true;
 
                 // found missing direction
                 if (missingDir)
                 {
                     diffM[i][j] = -1;
                     continue;
                 }
 
                 // calculate angle between directions
                 diffM[i][j] = fabs(dot_product(refDir, testDir));
 
                 if (diffM[i][j] < maxAngularError)
                     maxAngularError = diffM[i][j];
 
                 if (diffM[i][j]>1.0)
                     diffM[i][j] = 1.0;
             }
         }
 
         float angularError = 0.0;
         float lengthError = 0.0;
         int counter = 0;
         vnl_matrix< float > diffM_copy = diffM;
         for (int k=0; k<numDirections; k++)
         {
             float error = -1;
             int a,b; a=-1; b=-1;
             bool missingDir = false;
 
             // i: index of reference direction
             // j: index of test direction
             // find smalles error between two directions (large value -> small error)
             for (int i=0; i<numDirections; i++)
                 for (int j=0; j<numDirections; j++)
                 {
                     if (diffM[i][j]>error && diffM[i][j]<2)   // found valid error entry
                     {
                         error = diffM[i][j];
                         a = i;
                         b = j;
                         missingDir = false;
                     }
                     else if (diffM[i][j]<0 && error<0)    // found missing direction
                     {
                         a = i;
                         b = j;
                         missingDir = true;
                     }
                 }
 
             if (a<0 || b<0 || m_IgnoreMissingDirections && missingDir)
                 continue; // no more directions found
 
             if (a>=numRefDirs && b>=numTestDirs)
             {
                 MITK_INFO << "ERROR: missing test and reference direction. should not be possible. check code.";
                 continue;
             }
 
             // remove processed directions from error matrix
             diffM.set_row(a, 10.0);
             diffM.set_column(b, 10.0);
 
             if (a>=numRefDirs) // missing reference direction (find next closest)
             {
                 for (int i=0; i<numRefDirs; i++)
                     if (diffM_copy[i][b]>error)
                     {
                         error = diffM_copy[i][b];
                         a = i;
                     }
             }
             else if (b>=numTestDirs) // missing test direction (find next closest)
             {
                 for (int i=0; i<numTestDirs; i++)
                     if (diffM_copy[a][i]>error)
                     {
                         error = diffM_copy[a][i];
                         b = i;
                     }
             }
 
             float refLength = m_ReferenceImageSet->GetElement(a)->GetPixel(index).GetVnlVector().magnitude();
             float testLength = m_ImageSet->GetElement(b)->GetPixel(index).GetVnlVector().magnitude();
 
             if (a>=numRefDirs || b>=numTestDirs || error<0)
                 error = 0;
 
             m_LengthErrorVector.push_back( fabs(refLength-testLength) );
             m_AngularErrorVector.push_back( acos(error)*180.0/M_PI );
 
             m_MeanAngularError += m_AngularErrorVector.back();
             m_MeanLengthError += m_LengthErrorVector.back();
 
             angularError += m_AngularErrorVector.back();
             lengthError += m_LengthErrorVector.back();
             counter++;
         }
 
         if (counter>0)
         {
             lengthError /= counter;
             angularError /= counter;
         }
         oit2.Set(lengthError);
         oit.Set(angularError);
 
         ++oit;
         ++oit2;
         ++mit;
     }
 
     std::sort( m_AngularErrorVector.begin(), m_AngularErrorVector.end() );
     m_MeanAngularError /= m_AngularErrorVector.size();      // mean
     for (int i=0; i<m_AngularErrorVector.size(); i++)
     {
         float temp = m_AngularErrorVector.at(i) - m_MeanAngularError;
         m_VarAngularError += temp*temp;
 
         if ( m_AngularErrorVector.at(i)>m_MaxAngularError )
             m_MaxAngularError = m_AngularErrorVector.at(i);
         if ( m_AngularErrorVector.at(i)<m_MinAngularError )
             m_MinAngularError = m_AngularErrorVector.at(i);
     }
     if (m_AngularErrorVector.size()>1)
     {
         m_VarAngularError /= (m_AngularErrorVector.size()-1);   // variance
 
         // median
         if (m_AngularErrorVector.size()%2 == 0)
             m_MedianAngularError = 0.5*( m_AngularErrorVector.at( m_AngularErrorVector.size()/2 ) +  m_AngularErrorVector.at( m_AngularErrorVector.size()/2+1 ) );
         else
             m_MedianAngularError = m_AngularErrorVector.at( (m_AngularErrorVector.size()+1)/2 ) ;
     }
 
     std::sort( m_LengthErrorVector.begin(), m_LengthErrorVector.end() );
     m_MeanLengthError /= m_LengthErrorVector.size();      // mean
     for (int i=0; i<m_LengthErrorVector.size(); i++)
     {
         float temp = m_LengthErrorVector.at(i) - m_MeanLengthError;
         m_VarLengthError += temp*temp;
 
         if ( m_LengthErrorVector.at(i)>m_MaxLengthError )
             m_MaxLengthError = m_LengthErrorVector.at(i);
         if ( m_LengthErrorVector.at(i)<m_MinLengthError )
             m_MinLengthError = m_LengthErrorVector.at(i);
     }
     if (m_LengthErrorVector.size()>1)
     {
         m_VarLengthError /= (m_LengthErrorVector.size()-1);   // variance
 
         // median
         if (m_LengthErrorVector.size()%2 == 0)
             m_MedianLengthError = 0.5*( m_LengthErrorVector.at( m_LengthErrorVector.size()/2 ) +  m_LengthErrorVector.at( m_LengthErrorVector.size()/2+1 ) );
         else
             m_MedianLengthError = m_LengthErrorVector.at( (m_LengthErrorVector.size()+1)/2 ) ;
     }
 }
 
 }
 
 #endif // __itkEvaluateDirectionImagesFilter_cpp
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.cpp
index 4c76f5d2b5..68543c2b6e 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkEvaluateTractogramDirectionsFilter.cpp
@@ -1,353 +1,351 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef __itkEvaluateTractogramDirectionsFilter_cpp
 #define __itkEvaluateTractogramDirectionsFilter_cpp
 
 #include "itkEvaluateTractogramDirectionsFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionIterator.h>
 #include <itkImageDuplicator.h>
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#endif
+#include <boost/progress.hpp>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 namespace itk {
 
 template< class PixelType >
 EvaluateTractogramDirectionsFilter< PixelType >
 ::EvaluateTractogramDirectionsFilter():
     m_ReferenceImageSet(NULL),
     m_IgnoreMissingDirections(false),
     m_Eps(0.0001),
     m_UseInterpolation(false)
 {
     this->SetNumberOfOutputs(1);
 }
 
 template< class PixelType >
 itk::Vector<PixelType, 3> EvaluateTractogramDirectionsFilter< PixelType >::GetItkVector(double point[3])
 {
     itk::Vector<PixelType, 3> itkVector;
     itkVector[0] = point[0];
     itkVector[1] = point[1];
     itkVector[2] = point[2];
     return itkVector;
 }
 
 template< class PixelType >
 vnl_vector_fixed<PixelType, 3> EvaluateTractogramDirectionsFilter< PixelType >::GetVnlVector(double point[3])
 {
     vnl_vector_fixed<PixelType, 3> vnlVector;
     vnlVector[0] = point[0];
     vnlVector[1] = point[1];
     vnlVector[2] = point[2];
     return vnlVector;
 }
 
 template< class PixelType >
 vnl_vector_fixed<PixelType, 3> EvaluateTractogramDirectionsFilter< PixelType >::GetVnlVector(Vector<PixelType,3>& vector)
 {
     vnl_vector_fixed<PixelType, 3> vnlVector;
     vnlVector[0] = vector[0];
     vnlVector[1] = vector[1];
     vnlVector[2] = vector[2];
     return vnlVector;
 }
 
 template< class PixelType >
 itk::Point<PixelType, 3> EvaluateTractogramDirectionsFilter< PixelType >::GetItkPoint(double point[3])
 {
     itk::Point<PixelType, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 template< class PixelType >
 void EvaluateTractogramDirectionsFilter< PixelType >::GenerateData()
 {
     if (m_Tractogram.IsNull() || m_ReferenceImageSet.IsNull())
         return;
 
     if (m_UseInterpolation)
         MITK_INFO << "Using trilinear interpolation";
     else
         MITK_INFO << "Using nearest neighbor interpolation";
 
     if (m_IgnoreMissingDirections)
         MITK_INFO << "Ignoring missing directions";
     else
         MITK_INFO << "Penalizing missing directions";
 
     // angular error image
     typename OutputImageType::Pointer outputImage = OutputImageType::New();
     outputImage->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
     outputImage->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
     outputImage->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
     outputImage->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
     outputImage->Allocate();
     outputImage->FillBuffer(0.0);
 
     DoubleImageType::Pointer counterImage = DoubleImageType::New();
     counterImage->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
     counterImage->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
     counterImage->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
     counterImage->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
     counterImage->Allocate();
     counterImage->FillBuffer(0.0);
 
     std::vector< DoubleImageType::Pointer > directionFound;
     for (int i=0; i<m_ReferenceImageSet->Size(); i++)
     {
         DoubleImageType::Pointer check = DoubleImageType::New();
         check->SetOrigin( m_ReferenceImageSet->GetElement(0)->GetOrigin() );
         check->SetRegions( m_ReferenceImageSet->GetElement(0)->GetLargestPossibleRegion() );
         check->SetSpacing( m_ReferenceImageSet->GetElement(0)->GetSpacing() );
         check->SetDirection( m_ReferenceImageSet->GetElement(0)->GetDirection() );
         check->Allocate();
         check->FillBuffer(90);
         directionFound.push_back(check);
     }
 
     if (m_MaskImage.IsNull())
     {
         m_MaskImage = UCharImageType::New();
         m_MaskImage->SetOrigin( outputImage->GetOrigin() );
         m_MaskImage->SetRegions( outputImage->GetLargestPossibleRegion() );
         m_MaskImage->SetSpacing( outputImage->GetSpacing() );
         m_MaskImage->SetDirection( outputImage->GetDirection() );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
 
     m_MeanAngularError = 0.0;
     m_MedianAngularError = 0;
     m_MaxAngularError = 0.0;
     m_MinAngularError = itk::NumericTraits<float>::max();
     m_VarAngularError = 0.0;
     m_AngularErrorVector.clear();
 
     float minSpacing = 1;
     if(outputImage->GetSpacing()[0]<outputImage->GetSpacing()[1] && outputImage->GetSpacing()[0]<outputImage->GetSpacing()[2])
         minSpacing = outputImage->GetSpacing()[0];
     else if (outputImage->GetSpacing()[1] < outputImage->GetSpacing()[2])
         minSpacing = outputImage->GetSpacing()[1];
     else
         minSpacing = outputImage->GetSpacing()[2];
     FiberBundleType::Pointer fiberBundle = m_Tractogram->GetDeepCopy();
     fiberBundle->ResampleFibers(minSpacing/10);
 
     MITK_INFO << "Evaluating tractogram";
     vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
     boost::progress_display disp( fiberBundle->GetNumFibers() );
     for( int i=0; i<fiberBundle->GetNumFibers(); i++ )
     {
         vtkCell* cell = fiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (numPoints<2)
             continue;
 
         for( int j=0; j<numPoints; j++)
         {
             double* temp = points->GetPoint(j);
             itk::Point<PixelType, 3> vertex = GetItkPoint(temp);
             itk::Vector<PixelType> v = GetItkVector(temp);
 
             itk::Vector<PixelType, 3> dir(3);
             if (j<numPoints-1)
                 dir = GetItkVector(points->GetPoint(j+1))-v;
             else
                 dir = v-GetItkVector(points->GetPoint(j-1));
 
             vnl_vector_fixed< PixelType, 3 > fiberDir = GetVnlVector(dir);
             fiberDir.normalize();
 
             itk::Index<3> idx;
             itk::ContinuousIndex<float, 3> contIndex;
             m_MaskImage->TransformPhysicalPointToIndex(vertex, idx);
             m_MaskImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
             if (!m_UseInterpolation)    // use nearest neighbour interpolation
             {
                 if (!m_MaskImage->GetLargestPossibleRegion().IsInside(idx) || m_MaskImage->GetPixel(idx)<=0)
                     continue;
 
                 double angle = 90;
                 int usedIndex = -1;
                 for (int k=0; k<m_ReferenceImageSet->Size(); k++)     // and each test direction
                 {
                     vnl_vector_fixed< PixelType, 3 > refDir = m_ReferenceImageSet->GetElement(k)->GetPixel(idx).GetVnlVector();
                     if (refDir.magnitude()>m_Eps)  // normalize if not null
                         refDir.normalize();
                     else
                         continue;
 
                     // calculate angle between directions
                     double tempAngle = acos(fabs(dot_product(refDir, fiberDir)))*180.0/M_PI;
                     directionFound.at(k)->SetPixel(idx, tempAngle);
 
                     if (tempAngle < angle)
                     {
                         angle = tempAngle;
                         usedIndex = k;
                     }
                 }
                 if (usedIndex>=0)
                     directionFound.at(usedIndex)->SetPixel(idx, -1);
                 else if (m_IgnoreMissingDirections)
                     angle = 0;
 
                 counterImage->SetPixel(idx, counterImage->GetPixel(idx)+1);
                 outputImage->SetPixel(idx, outputImage->GetPixel(idx)+angle);
                 continue;
             }
 
             double frac_x = contIndex[0] - idx[0];
             double frac_y = contIndex[1] - idx[1];
             double frac_z = contIndex[2] - idx[2];
             if (frac_x<0)
             {
                 idx[0] -= 1;
                 frac_x += 1;
             }
             if (frac_y<0)
             {
                 idx[1] -= 1;
                 frac_y += 1;
             }
             if (frac_z<0)
             {
                 idx[2] -= 1;
                 frac_z += 1;
             }
 
             // use trilinear interpolation
             itk::Index<3> newIdx;
             for (int x=0; x<2; x++)
             {
                 frac_x = 1-frac_x;
                 for (int y=0; y<2; y++)
                 {
                     frac_y = 1-frac_y;
                     for (int z=0; z<2; z++)
                     {
                         frac_z = 1-frac_z;
 
                         newIdx[0] = idx[0]+x;
                         newIdx[1] = idx[1]+y;
                         newIdx[2] = idx[2]+z;
 
                         double frac = frac_x*frac_y*frac_z;
 
                         // is position valid?
                         if (!m_MaskImage->GetLargestPossibleRegion().IsInside(newIdx) || m_MaskImage->GetPixel(newIdx)<=0)
                             continue;
 
                         double angle = 90;
                         int usedIndex = -1;
                         for (int k=0; k<m_ReferenceImageSet->Size(); k++)     // and each test direction
                         {
                             vnl_vector_fixed< PixelType, 3 > refDir = m_ReferenceImageSet->GetElement(k)->GetPixel(newIdx).GetVnlVector();
                             if (refDir.magnitude()>m_Eps)  // normalize if not null
                                 refDir.normalize();
                             else
                                 continue;
 
                             // calculate angle between directions
                             double tempAngle = acos(fabs(dot_product(refDir, fiberDir)))*180.0/M_PI;
                             directionFound.at(k)->SetPixel(newIdx, tempAngle);
 
                             if (tempAngle < angle)
                             {
                                 angle = tempAngle;
                                 usedIndex = k;
                             }
                         }
                         if (usedIndex>=0)
                             directionFound.at(usedIndex)->SetPixel(newIdx, -1);
                         else if (m_IgnoreMissingDirections)
                             angle = 0;
 
                         counterImage->SetPixel(newIdx, counterImage->GetPixel(newIdx)+1);
                         outputImage->SetPixel(newIdx, outputImage->GetPixel(newIdx)+frac*angle);
                     }
                 }
             }
         }
         ++disp;
     }
 
     ImageRegionIterator< OutputImageType > oit(outputImage, outputImage->GetLargestPossibleRegion());
     ImageRegionIterator< UCharImageType > mit(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
     ImageRegionIterator< DoubleImageType > cit(counterImage, counterImage->GetLargestPossibleRegion());
 
 
     if (!m_IgnoreMissingDirections)
         MITK_INFO << "Creatings statistics and accounting for missing directions";
     else
         MITK_INFO << "Creatings statistics";
     boost::progress_display disp2(outputImage->GetLargestPossibleRegion().GetNumberOfPixels());
     while( !oit.IsAtEnd() )
     {
         if ( mit.Get()>0)
         {
             if ( cit.Get()>m_Eps )
                 oit.Set(oit.Get()/cit.Get());
 
             if (!m_IgnoreMissingDirections)
             {
                 int missingCount = 0;
 
                 if ( cit.Get()>m_Eps )
                     missingCount++;
 
                 for (int i=0; i<directionFound.size(); i++)
                 {
                     if ( directionFound.at(i)->GetPixel(oit.GetIndex())>0 && m_ReferenceImageSet->GetElement(i)->GetPixel(oit.GetIndex()).GetVnlVector().magnitude()>m_Eps )
                     {
                         oit.Set(oit.Get()+directionFound.at(i)->GetPixel(oit.GetIndex()));
                         missingCount++;
                     }
                 }
                 if (missingCount>1)
                     oit.Set(oit.Get()/missingCount);
             }
 
             if (oit.Get()>m_MaxAngularError)
                 m_MaxAngularError = oit.Get();
             if (oit.Get()<m_MinAngularError)
                 m_MinAngularError = oit.Get();
         }
 
         ++oit;
         ++cit;
         ++mit;
         ++disp2;
     }
 
     this->SetNthOutput(0, outputImage);
 }
 
 }
 
 #endif // __itkEvaluateTractogramDirectionsFilter_cpp
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp
index 19cb366e2b..a93e25619b 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp
@@ -1,512 +1,510 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #include "itkGibbsTrackingFilter.h"
 
 // MITK
 #include <itkOrientationDistributionFunction.h>
 #include <itkDiffusionQballGeneralizedFaImageFilter.h>
 #include <mitkStandardFileLocations.h>
 #include <mitkFiberBuilder.h>
 #include <mitkMetropolisHastingsSampler.h>
 //#include <mitkEnergyComputer.h>
 #include <itkTensorImageToQBallImageFilter.h>
 #include <mitkGibbsEnergyComputer.h>
 
 // ITK
 #include <itkImageDuplicator.h>
 #include <itkResampleImageFilter.h>
 #include <itkTimeProbe.h>
 
 // MISC
 #include <fstream>
 // #include <QFile>
 #include <tinyxml.h>
 #include <math.h>
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#  include <boost/lexical_cast.hpp>
-#  include <boost/algorithm/string.hpp>
-#endif
+#include <boost/progress.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
 
 namespace itk{
 
 template< class ItkQBallImageType >
 GibbsTrackingFilter< ItkQBallImageType >::GibbsTrackingFilter():
     m_StartTemperature(0.1),
     m_EndTemperature(0.001),
     m_Iterations(500000),
     m_ParticleWeight(0),
     m_ParticleWidth(0),
     m_ParticleLength(0),
     m_ConnectionPotential(10),
     m_InexBalance(0),
     m_ParticlePotential(0.2),
     m_MinFiberLength(10),
     m_AbortTracking(false),
     m_NumConnections(0),
     m_NumParticles(0),
     m_NumAcceptedFibers(0),
     m_CurrentStep(0),
     m_BuildFibers(false),
     m_Steps(10),
     m_ProposalAcceptance(0),
     m_CurvatureThreshold(0.7),
     m_DuplicateImage(true),
     m_RandomSeed(-1),
     m_LoadParameterFile(""),
     m_LutPath(""),
     m_IsInValidState(true)
 {
 
 }
 
 template< class ItkQBallImageType >
 GibbsTrackingFilter< ItkQBallImageType >::~GibbsTrackingFilter()
 {
 
 }
 
 // fill output fiber bundle datastructure
 template< class ItkQBallImageType >
 typename GibbsTrackingFilter< ItkQBallImageType >::FiberPolyDataType GibbsTrackingFilter< ItkQBallImageType >::GetFiberBundle()
 {
     if (!m_AbortTracking)
     {
         m_BuildFibers = true;
         while (m_BuildFibers){}
     }
 
     return m_FiberPolyData;
 }
 
 template< class ItkQBallImageType >
 void
 GibbsTrackingFilter< ItkQBallImageType >
 ::EstimateParticleWeight()
 {
     MITK_INFO << "GibbsTrackingFilter: estimating particle weight";
 
     float minSpacing;
     if(m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[1] && m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[2])
         minSpacing = m_QBallImage->GetSpacing()[0];
     else if (m_QBallImage->GetSpacing()[1] < m_QBallImage->GetSpacing()[2])
         minSpacing = m_QBallImage->GetSpacing()[1];
     else
         minSpacing = m_QBallImage->GetSpacing()[2];
     float m_ParticleLength = 1.5*minSpacing;
     float m_ParticleWidth = 0.5*minSpacing;
 
     // seed random generators
     Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
     if (m_RandomSeed>-1)
         randGen->SetSeed(m_RandomSeed);
     else
         randGen->SetSeed();
 
     // instantiate all necessary components
     SphereInterpolator* interpolator = new SphereInterpolator(m_LutPath);
     // handle lookup table not found cases
     if( !interpolator->IsInValidState() )
     {
       m_IsInValidState = false;
       m_AbortTracking = true;
       m_BuildFibers = false;
       mitkThrow() << "Unable to load lookup tables.";
     }
     ParticleGrid* particleGrid = new ParticleGrid(m_MaskImage, m_ParticleLength, m_ParticleGridCellCapacity);
     GibbsEnergyComputer* encomp = new GibbsEnergyComputer(m_QBallImage, m_MaskImage, particleGrid, interpolator, randGen);
 
     //    EnergyComputer* encomp = new EnergyComputer(m_QBallImage, m_MaskImage, particleGrid, interpolator, randGen);
     MetropolisHastingsSampler* sampler = new MetropolisHastingsSampler(particleGrid, encomp, randGen, m_CurvatureThreshold);
 
     float alpha = log(m_EndTemperature/m_StartTemperature);
     m_ParticleWeight = 0.01;
     int ppv = 0;
     // main loop
     int neededParts = 3000;
     while (ppv<neededParts)
     {
         if (ppv<1000)
             m_ParticleWeight /= 2;
         else
             m_ParticleWeight = ppv*m_ParticleWeight/neededParts;
 
         encomp->SetParameters(m_ParticleWeight,m_ParticleWidth,m_ConnectionPotential*m_ParticleLength*m_ParticleLength,m_CurvatureThreshold,m_InexBalance,m_ParticlePotential);
         for( int step = 0; step < 10; step++ )
         {
             // update temperatur for simulated annealing process
             float temperature = m_StartTemperature * exp(alpha*(((1.0)*step)/((1.0)*10)));
             sampler->SetTemperature(temperature);
 
             for (unsigned long i=0; i<10000; i++)
                 sampler->MakeProposal();
         }
         ppv = particleGrid->m_NumParticles;
         particleGrid->ResetGrid();
     }
     delete sampler;
     delete encomp;
     delete particleGrid;
     delete interpolator;
 
     MITK_INFO << "GibbsTrackingFilter: finished estimating particle weight";
 }
 
 // perform global tracking
 template< class ItkQBallImageType >
 void GibbsTrackingFilter< ItkQBallImageType >::GenerateData()
 {
     TimeProbe preClock; preClock.Start();
     // check if input is qball or tensor image and generate qball if necessary
     if (m_QBallImage.IsNull() && m_TensorImage.IsNotNull())
     {
         TensorImageToQBallImageFilter<float,float>::Pointer filter = TensorImageToQBallImageFilter<float,float>::New();
         filter->SetInput( m_TensorImage );
         filter->Update();
         m_QBallImage = filter->GetOutput();
     }
     else if (m_DuplicateImage) // generate local working copy of QBall image (if not disabled)
     {
         typedef itk::ImageDuplicator< ItkQBallImageType > DuplicateFilterType;
         typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
         duplicator->SetInputImage( m_QBallImage );
         duplicator->Update();
         m_QBallImage = duplicator->GetOutput();
     }
 
     // perform mean subtraction on odfs
     typedef ImageRegionIterator< ItkQBallImageType > InputIteratorType;
     InputIteratorType it(m_QBallImage, m_QBallImage->GetLargestPossibleRegion() );
     it.GoToBegin();
     while (!it.IsAtEnd())
     {
         itk::OrientationDistributionFunction<float, QBALL_ODFSIZE> odf(it.Get().GetDataPointer());
         float mean = odf.GetMeanValue();
         odf -= mean;
         it.Set(odf.GetDataPointer());
         ++it;
     }
 
     // check if mask image is given if it needs resampling
     PrepareMaskImage();
 
     // load parameter file
     LoadParameters();
 
     // prepare parameters
     float minSpacing;
     if(m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[1] && m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[2])
         minSpacing = m_QBallImage->GetSpacing()[0];
     else if (m_QBallImage->GetSpacing()[1] < m_QBallImage->GetSpacing()[2])
         minSpacing = m_QBallImage->GetSpacing()[1];
     else
         minSpacing = m_QBallImage->GetSpacing()[2];
 
     if(m_ParticleLength == 0)
         m_ParticleLength = 1.5*minSpacing;
     if(m_ParticleWidth == 0)
         m_ParticleWidth = 0.5*minSpacing;
 
     if(m_ParticleWeight == 0)
         EstimateParticleWeight();
 
     float alpha = log(m_EndTemperature/m_StartTemperature);
     m_Steps = m_Iterations/10000;
     if (m_Steps<10)
         m_Steps = 10;
     if (m_Steps>m_Iterations)
     {
         MITK_INFO << "GibbsTrackingFilter: not enough iterations!";
         m_AbortTracking = true;
     }
     if (m_CurvatureThreshold < mitk::eps)
         m_CurvatureThreshold = 0;
     unsigned long singleIts = (unsigned long)((1.0*m_Iterations) / (1.0*m_Steps));
 
     // seed random generators
     Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
     if (m_RandomSeed>-1)
         randGen->SetSeed(m_RandomSeed);
     else
         randGen->SetSeed();
 
     // load sphere interpolator to evaluate the ODFs
     SphereInterpolator* interpolator = new SphereInterpolator(m_LutPath);
 
     // handle lookup table not found cases
     if( !interpolator->IsInValidState() )
     {
       m_IsInValidState = false;
       m_AbortTracking = true;
       m_BuildFibers = false;
       mitkThrow() << "Unable to load lookup tables.";
     }
     // initialize the actual tracking components (ParticleGrid, Metropolis Hastings Sampler and Energy Computer)
     ParticleGrid* particleGrid;
     GibbsEnergyComputer* encomp;
     MetropolisHastingsSampler* sampler;
     try{
         particleGrid = new ParticleGrid(m_MaskImage, m_ParticleLength, m_ParticleGridCellCapacity);
         encomp = new GibbsEnergyComputer(m_QBallImage, m_MaskImage, particleGrid, interpolator, randGen);
         encomp->SetParameters(m_ParticleWeight,m_ParticleWidth,m_ConnectionPotential*m_ParticleLength*m_ParticleLength,m_CurvatureThreshold,m_InexBalance,m_ParticlePotential);
         sampler = new MetropolisHastingsSampler(particleGrid, encomp, randGen, m_CurvatureThreshold);
     }
     catch(...)
     {
         MITK_ERROR  << "Particle grid allocation failed. Not enough memory? Try to increase the particle length.";
         m_IsInValidState = false;
         m_AbortTracking = true;
         m_BuildFibers = false;
         return;
     }
 
     MITK_INFO << "----------------------------------------";
     MITK_INFO << "Iterations: " << m_Iterations;
     MITK_INFO << "Steps: " << m_Steps;
     MITK_INFO << "Particle length: " << m_ParticleLength;
     MITK_INFO << "Particle width: " << m_ParticleWidth;
     MITK_INFO << "Particle weight: " << m_ParticleWeight;
     MITK_INFO << "Start temperature: " << m_StartTemperature;
     MITK_INFO << "End temperature: " << m_EndTemperature;
     MITK_INFO << "In/Ex balance: " << m_InexBalance;
     MITK_INFO << "Min. fiber length: " << m_MinFiberLength;
     MITK_INFO << "Curvature threshold: " << m_CurvatureThreshold;
     MITK_INFO << "Random seed: " << m_RandomSeed;
     MITK_INFO << "----------------------------------------";
 
     // main loop
     preClock.Stop();
     TimeProbe clock; clock.Start();
     m_NumAcceptedFibers = 0;
     unsigned long counter = 1;
 
     boost::progress_display disp(m_Steps*singleIts);
     if (!m_AbortTracking)
     for( m_CurrentStep = 1; m_CurrentStep <= m_Steps; m_CurrentStep++ )
     {
         // update temperatur for simulated annealing process
         float temperature = m_StartTemperature * exp(alpha*(((1.0)*m_CurrentStep)/((1.0)*m_Steps)));
         sampler->SetTemperature(temperature);
 
         for (unsigned long i=0; i<singleIts; i++)
         {
             ++disp;
             if (m_AbortTracking)
                 break;
 
             sampler->MakeProposal();
 
             if (m_BuildFibers || (i==singleIts-1 && m_CurrentStep==m_Steps))
             {
                 m_ProposalAcceptance = (float)sampler->GetNumAcceptedProposals()/counter;
                 m_NumParticles = particleGrid->m_NumParticles;
                 m_NumConnections = particleGrid->m_NumConnections;
 
                 FiberBuilder fiberBuilder(particleGrid, m_MaskImage);
                 m_FiberPolyData = fiberBuilder.iterate(m_MinFiberLength);
                 m_NumAcceptedFibers = m_FiberPolyData->GetNumberOfLines();
                 m_BuildFibers = false;
             }
             counter++;
         }
 
         m_ProposalAcceptance = (float)sampler->GetNumAcceptedProposals()/counter;
         m_NumParticles = particleGrid->m_NumParticles;
         m_NumConnections = particleGrid->m_NumConnections;
 
         if (m_AbortTracking)
             break;
     }
     if (m_AbortTracking)
     {
         FiberBuilder fiberBuilder(particleGrid, m_MaskImage);
         m_FiberPolyData = fiberBuilder.iterate(m_MinFiberLength);
         m_NumAcceptedFibers = m_FiberPolyData->GetNumberOfLines();
     }
     clock.Stop();
 
     delete sampler;
     delete encomp;
     delete interpolator;
     delete particleGrid;
     m_AbortTracking = true;
     m_BuildFibers = false;
 
     int h = clock.GetTotal()/3600;
     int m = ((int)clock.GetTotal()%3600)/60;
     int s = (int)clock.GetTotal()%60;
     MITK_INFO << "GibbsTrackingFilter: finished gibbs tracking in " << h << "h, " << m << "m and " << s << "s";
     m = (int)preClock.GetTotal()/60;
     s = (int)preClock.GetTotal()%60;
     MITK_INFO << "GibbsTrackingFilter: preparation of the data took " << m << "m and " << s << "s";
     MITK_INFO << "GibbsTrackingFilter: " << m_NumAcceptedFibers << " fibers accepted";
 
     SaveParameters();
 }
 
 template< class ItkQBallImageType >
 void GibbsTrackingFilter< ItkQBallImageType >::PrepareMaskImage()
 {
     if(m_MaskImage.IsNull())
     {
         MITK_INFO << "GibbsTrackingFilter: generating default mask image";
         m_MaskImage = ItkFloatImageType::New();
         m_MaskImage->SetSpacing( m_QBallImage->GetSpacing() );
         m_MaskImage->SetOrigin( m_QBallImage->GetOrigin() );
         m_MaskImage->SetDirection( m_QBallImage->GetDirection() );
         m_MaskImage->SetRegions( m_QBallImage->GetLargestPossibleRegion() );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1.0);
     }
     else if ( m_MaskImage->GetLargestPossibleRegion().GetSize()[0]!=m_QBallImage->GetLargestPossibleRegion().GetSize()[0] ||
          m_MaskImage->GetLargestPossibleRegion().GetSize()[1]!=m_QBallImage->GetLargestPossibleRegion().GetSize()[1] ||
          m_MaskImage->GetLargestPossibleRegion().GetSize()[2]!=m_QBallImage->GetLargestPossibleRegion().GetSize()[2] ||
          m_MaskImage->GetSpacing()[0]!=m_QBallImage->GetSpacing()[0] ||
          m_MaskImage->GetSpacing()[1]!=m_QBallImage->GetSpacing()[1] ||
          m_MaskImage->GetSpacing()[2]!=m_QBallImage->GetSpacing()[2] )
     {
         MITK_INFO << "GibbsTrackingFilter: resampling mask image";
         typedef itk::ResampleImageFilter< ItkFloatImageType, ItkFloatImageType, float > ResamplerType;
         ResamplerType::Pointer resampler = ResamplerType::New();
         resampler->SetOutputSpacing( m_QBallImage->GetSpacing() );
         resampler->SetOutputOrigin( m_QBallImage->GetOrigin() );
         resampler->SetOutputDirection( m_QBallImage->GetDirection() );
         resampler->SetSize( m_QBallImage->GetLargestPossibleRegion().GetSize() );
 
         resampler->SetInput( m_MaskImage );
         resampler->SetDefaultPixelValue(0.0);
         resampler->Update();
         m_MaskImage = resampler->GetOutput();
         MITK_INFO << "GibbsTrackingFilter: resampling finished";
     }
 }
 
 // load tracking paramters from xml file (.gtp)
 template< class ItkQBallImageType >
 bool GibbsTrackingFilter< ItkQBallImageType >::LoadParameters()
 {
     m_AbortTracking = true;
     try
     {
         if( m_LoadParameterFile.length()==0 )
         {
             m_AbortTracking = false;
             return true;
         }
 
         MITK_INFO << "GibbsTrackingFilter: loading parameter file " << m_LoadParameterFile;
 
         TiXmlDocument doc( m_LoadParameterFile );
         doc.LoadFile();
 
         TiXmlHandle hDoc(&doc);
         TiXmlElement* pElem;
         TiXmlHandle hRoot(0);
 
         pElem = hDoc.FirstChildElement().Element();
         hRoot = TiXmlHandle(pElem);
         pElem = hRoot.FirstChildElement("parameter_set").Element();
 
         string iterations(pElem->Attribute("iterations"));
         m_Iterations = boost::lexical_cast<unsigned long>(iterations);
 
         string particleLength(pElem->Attribute("particle_length"));
         m_ParticleLength = boost::lexical_cast<float>(particleLength);
 
         string particleWidth(pElem->Attribute("particle_width"));
         m_ParticleWidth = boost::lexical_cast<float>(particleWidth);
 
         string partWeight(pElem->Attribute("particle_weight"));
         m_ParticleWeight = boost::lexical_cast<float>(partWeight);
 
         string startTemp(pElem->Attribute("temp_start"));
         m_StartTemperature = boost::lexical_cast<float>(startTemp);
 
         string endTemp(pElem->Attribute("temp_end"));
         m_EndTemperature = boost::lexical_cast<float>(endTemp);
 
         string inExBalance(pElem->Attribute("inexbalance"));
         m_InexBalance = boost::lexical_cast<float>(inExBalance);
 
         string fiberLength(pElem->Attribute("fiber_length"));
         m_MinFiberLength = boost::lexical_cast<float>(fiberLength);
 
         string curvThres(pElem->Attribute("curvature_threshold"));
         m_CurvatureThreshold = cos(boost::lexical_cast<float>(curvThres)*M_PI/180);
         m_AbortTracking = false;
         MITK_INFO << "GibbsTrackingFilter: parameter file loaded successfully";
         return true;
     }
     catch(...)
     {
         MITK_INFO << "GibbsTrackingFilter: could not load parameter file";
         return false;
     }
 }
 
 // save current tracking paramters to xml file (.gtp)
 template< class ItkQBallImageType >
 bool GibbsTrackingFilter< ItkQBallImageType >::SaveParameters()
 {
     try
     {
         if( m_SaveParameterFile.length()==0 )
         {
             MITK_INFO << "GibbsTrackingFilter: no filename specified to save parameters";
             return true;
         }
 
         MITK_INFO << "GibbsTrackingFilter: saving parameter file " << m_SaveParameterFile;
 
         TiXmlDocument documentXML;
         TiXmlDeclaration* declXML = new TiXmlDeclaration( "1.0", "", "" );
         documentXML.LinkEndChild( declXML );
 
         TiXmlElement* mainXML = new TiXmlElement("global_tracking_parameter_file");
         mainXML->SetAttribute("file_version",  "0.1");
         documentXML.LinkEndChild(mainXML);
 
         TiXmlElement* paramXML = new TiXmlElement("parameter_set");
         paramXML->SetAttribute("iterations", boost::lexical_cast<string>(m_Iterations));
         paramXML->SetAttribute("particle_length", boost::lexical_cast<string>(m_ParticleLength));
         paramXML->SetAttribute("particle_width", boost::lexical_cast<string>(m_ParticleWidth));
         paramXML->SetAttribute("particle_weight", boost::lexical_cast<string>(m_ParticleWeight));
         paramXML->SetAttribute("temp_start", boost::lexical_cast<string>(m_StartTemperature));
         paramXML->SetAttribute("temp_end", boost::lexical_cast<string>(m_EndTemperature));
         paramXML->SetAttribute("inexbalance", boost::lexical_cast<string>(m_InexBalance));
         paramXML->SetAttribute("fiber_length", boost::lexical_cast<string>(m_MinFiberLength));
         paramXML->SetAttribute("curvature_threshold", boost::lexical_cast<string>(m_CurvatureThreshold));
         mainXML->LinkEndChild(paramXML);
 
         if(!boost::algorithm::ends_with(m_SaveParameterFile, ".gtp"))
             m_SaveParameterFile.append(".gtp");
         documentXML.SaveFile( m_SaveParameterFile );
 
         MITK_INFO << "GibbsTrackingFilter: parameter file saved successfully";
         return true;
     }
     catch(...)
     {
         MITK_INFO << "GibbsTrackingFilter: could not save parameter file";
         return false;
     }
 }
 
 }
 
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp
index 7ada2f543f..f305bb165a 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp
@@ -1,228 +1,226 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Coindex[1]right (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #include "itkTractDensityImageFilter.h"
 
 // VTK
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 
 // misc
 #include <math.h>
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#endif
+#include <boost/progress.hpp>
 
 namespace itk{
 
 template< class OutputImageType >
 TractDensityImageFilter< OutputImageType >::TractDensityImageFilter()
     : m_BinaryOutput(false)
     , m_InvertImage(false)
     , m_UpsamplingFactor(1)
     , m_InputImage(NULL)
     , m_UseImageGeometry(false)
     , m_OutputAbsoluteValues(false)
 {
 
 }
 
 template< class OutputImageType >
 TractDensityImageFilter< OutputImageType >::~TractDensityImageFilter()
 {
 }
 
 template< class OutputImageType >
 itk::Point<float, 3> TractDensityImageFilter< OutputImageType >::GetItkPoint(double point[3])
 {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 template< class OutputImageType >
 void TractDensityImageFilter< OutputImageType >::GenerateData()
 {
     // generate upsampled image
     mitk::Geometry3D::Pointer geometry = m_FiberBundle->GetGeometry();
     typename OutputImageType::Pointer outImage = this->GetOutput();
 
     // calculate new image parameters
     itk::Vector<double,3> newSpacing;
     mitk::Point3D newOrigin;
     itk::Matrix<double, 3, 3> newDirection;
     ImageRegion<3> upsampledRegion;
     if (m_UseImageGeometry && !m_InputImage.IsNull())
     {
         MITK_INFO << "TractDensityImageFilter: using image geometry";
         newSpacing = m_InputImage->GetSpacing()/m_UpsamplingFactor;
         upsampledRegion = m_InputImage->GetLargestPossibleRegion();
         newOrigin = m_InputImage->GetOrigin();
         typename OutputImageType::RegionType::SizeType size = upsampledRegion.GetSize();
         size[0] *= m_UpsamplingFactor;
         size[1] *= m_UpsamplingFactor;
         size[2] *= m_UpsamplingFactor;
         upsampledRegion.SetSize(size);
         newDirection = m_InputImage->GetDirection();
     }
     else
     {
         MITK_INFO << "TractDensityImageFilter: using fiber bundle geometry";
         newSpacing = geometry->GetSpacing()/m_UpsamplingFactor;
         newOrigin = geometry->GetOrigin();
         mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
         newOrigin[0] += bounds.GetElement(0);
         newOrigin[1] += bounds.GetElement(2);
         newOrigin[2] += bounds.GetElement(4);
 
         for (int i=0; i<3; i++)
             for (int j=0; j<3; j++)
                 newDirection[j][i] = geometry->GetMatrixColumn(i)[j];
         upsampledRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
         upsampledRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
         upsampledRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
     }
     typename OutputImageType::RegionType::SizeType upsampledSize = upsampledRegion.GetSize();
 
     // apply new image parameters
     outImage->SetSpacing( newSpacing );
     outImage->SetOrigin( newOrigin );
     outImage->SetDirection( newDirection );
     outImage->SetRegions( upsampledRegion );
     outImage->Allocate();
     outImage->FillBuffer(0.0);
 
     int w = upsampledSize[0];
     int h = upsampledSize[1];
     int d = upsampledSize[2];
 
     // set/initialize output
     OutPixelType* outImageBufferPointer = (OutPixelType*)outImage->GetBufferPointer();
 
     // resample fiber bundle
     float minSpacing = 1;
     if(newSpacing[0]<newSpacing[1] && newSpacing[0]<newSpacing[2])
         minSpacing = newSpacing[0];
     else if (newSpacing[1] < newSpacing[2])
         minSpacing = newSpacing[1];
     else
         minSpacing = newSpacing[2];
 
     MITK_INFO << "TractDensityImageFilter: resampling fibers to ensure sufficient voxel coverage";
     m_FiberBundle = m_FiberBundle->GetDeepCopy();
     m_FiberBundle->ResampleFibers(minSpacing);
 
     MITK_INFO << "TractDensityImageFilter: starting image generation";
     vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
     vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
     vLines->InitTraversal();
     int numFibers = m_FiberBundle->GetNumFibers();
     boost::progress_display disp(numFibers);
     for( int i=0; i<numFibers; i++ )
     {
         ++disp;
         vtkIdType   numPoints(0);
         vtkIdType*  points(NULL);
         vLines->GetNextCell ( numPoints, points );
 
         // fill output image
         for( int j=0; j<numPoints; j++)
         {
             itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[j]));
             itk::Index<3> index;
             itk::ContinuousIndex<float, 3> contIndex;
             outImage->TransformPhysicalPointToIndex(vertex, index);
             outImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
             float frac_x = contIndex[0] - index[0];
             float frac_y = contIndex[1] - index[1];
             float frac_z = contIndex[2] - index[2];
 
             if (frac_x<0)
             {
                 index[0] -= 1;
                 frac_x += 1;
             }
             if (frac_y<0)
             {
                 index[1] -= 1;
                 frac_y += 1;
             }
             if (frac_z<0)
             {
                 index[2] -= 1;
                 frac_z += 1;
             }
 
             frac_x = 1-frac_x;
             frac_y = 1-frac_y;
             frac_z = 1-frac_z;
 
             // int coordinates inside image?
             if (index[0] < 0 || index[0] >= w-1)
                 continue;
             if (index[1] < 0 || index[1] >= h-1)
                 continue;
             if (index[2] < 0 || index[2] >= d-1)
                 continue;
 
             if (m_BinaryOutput)
             {
                 outImageBufferPointer[( index[0]   + w*(index[1]  + h*index[2]  ))] = 1;
                 outImageBufferPointer[( index[0]   + w*(index[1]+1+ h*index[2]  ))] = 1;
                 outImageBufferPointer[( index[0]   + w*(index[1]  + h*index[2]+h))] = 1;
                 outImageBufferPointer[( index[0]   + w*(index[1]+1+ h*index[2]+h))] = 1;
                 outImageBufferPointer[( index[0]+1 + w*(index[1]  + h*index[2]  ))] = 1;
                 outImageBufferPointer[( index[0]+1 + w*(index[1]  + h*index[2]+h))] = 1;
                 outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]  ))] = 1;
                 outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]+h))] = 1;
             }
             else
             {
                 outImageBufferPointer[( index[0]   + w*(index[1]  + h*index[2]  ))] += (  frac_x)*(  frac_y)*(  frac_z);
                 outImageBufferPointer[( index[0]   + w*(index[1]+1+ h*index[2]  ))] += (  frac_x)*(1-frac_y)*(  frac_z);
                 outImageBufferPointer[( index[0]   + w*(index[1]  + h*index[2]+h))] += (  frac_x)*(  frac_y)*(1-frac_z);
                 outImageBufferPointer[( index[0]   + w*(index[1]+1+ h*index[2]+h))] += (  frac_x)*(1-frac_y)*(1-frac_z);
                 outImageBufferPointer[( index[0]+1 + w*(index[1]  + h*index[2]  ))] += (1-frac_x)*(  frac_y)*(  frac_z);
                 outImageBufferPointer[( index[0]+1 + w*(index[1]  + h*index[2]+h))] += (1-frac_x)*(  frac_y)*(1-frac_z);
                 outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]  ))] += (1-frac_x)*(1-frac_y)*(  frac_z);
                 outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]+h))] += (1-frac_x)*(1-frac_y)*(1-frac_z);
             }
         }
     }
 
     if (!m_OutputAbsoluteValues && !m_BinaryOutput)
     {
         MITK_INFO << "TractDensityImageFilter: max-normalizing output image";
         OutPixelType max = 0;
         for (int i=0; i<w*h*d; i++)
             if (max < outImageBufferPointer[i])
                 max = outImageBufferPointer[i];
         if (max>0)
             for (int i=0; i<w*h*d; i++)
                 outImageBufferPointer[i] /= max;
     }
     if (m_InvertImage)
     {
         MITK_INFO << "TractDensityImageFilter: inverting image";
         for (int i=0; i<w*h*d; i++)
             outImageBufferPointer[i] = 1-outImageBufferPointer[i];
     }
     MITK_INFO << "TractDensityImageFilter: finished processing";
 }
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
index d9ed16f2b6..b5f3974b19 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
@@ -1,713 +1,711 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "itkTractsToDWIImageFilter.h"
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#endif
+#include <boost/progress.hpp>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkImageFileWriter.h>
 #include <itkRescaleIntensityImageFilter.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 #include <itkResampleDwiImageFilter.h>
 #include <itkKspaceImageFilter.h>
 #include <itkDftImageFilter.h>
 #include <itkAddImageFilter.h>
 
 namespace itk
 {
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::TractsToDWIImageFilter()
     : m_CircleDummy(false)
     , m_VolumeAccuracy(10)
     , m_Upsampling(1)
     , m_NumberOfRepetitions(1)
     , m_EnforcePureFiberVoxels(false)
     , m_InterpolationShrink(1000)
     , m_FiberRadius(0)
     , m_SignalScale(25)
     , m_kOffset(0)
     , m_tLine(1)
     , m_UseInterpolation(false)
     , m_SimulateRelaxation(true)
     , m_tInhom(50)
     , m_TE(100)
     , m_FrequencyMap(NULL)
     , m_EddyGradientStrength(0.001)
     , m_SimulateEddyCurrents(false)
 {
     m_Spacing.Fill(2.5); m_Origin.Fill(0.0);
     m_DirectionMatrix.SetIdentity();
     m_ImageRegion.SetSize(0, 10);
     m_ImageRegion.SetSize(1, 10);
     m_ImageRegion.SetSize(2, 10);
 }
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::~TractsToDWIImageFilter()
 {
 
 }
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::DoubleDwiType::Pointer TractsToDWIImageFilter< PixelType >::DoKspaceStuff( std::vector< DoubleDwiType::Pointer >& images )
 {
     // create slice object
     ImageRegion<2> sliceRegion;
     sliceRegion.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
     sliceRegion.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
     Vector< double, 2 > sliceSpacing;
     sliceSpacing[0] = m_UpsampledSpacing[0];
     sliceSpacing[1] = m_UpsampledSpacing[1];
 
     // frequency map slice
     SliceType::Pointer fMap = NULL;
     if (m_FrequencyMap.IsNotNull())
     {
         fMap = SliceType::New();
         ImageRegion<2> region;
         region.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
         region.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
         fMap->SetLargestPossibleRegion( region );
         fMap->SetBufferedRegion( region );
         fMap->SetRequestedRegion( region );
         fMap->Allocate();
     }
 
     DoubleDwiType::Pointer newImage = DoubleDwiType::New();
     newImage->SetSpacing( m_Spacing );
     newImage->SetOrigin( m_Origin );
     newImage->SetDirection( m_DirectionMatrix );
     newImage->SetLargestPossibleRegion( m_ImageRegion );
     newImage->SetBufferedRegion( m_ImageRegion );
     newImage->SetRequestedRegion( m_ImageRegion );
     newImage->SetVectorLength( images.at(0)->GetVectorLength() );
     newImage->Allocate();
 
     MatrixType transform = m_DirectionMatrix;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
         {
             if (j<2)
                 transform[i][j] *= m_UpsampledSpacing[j];
             else
                 transform[i][j] *= m_Spacing[j];
         }
 
     boost::progress_display disp(images.at(0)->GetVectorLength()*images.at(0)->GetLargestPossibleRegion().GetSize(2));
     for (int g=0; g<images.at(0)->GetVectorLength(); g++)
         for (int z=0; z<images.at(0)->GetLargestPossibleRegion().GetSize(2); z++)
         {
             std::vector< SliceType::Pointer > compartmentSlices;
             std::vector< double > t2Vector;
 
             for (int i=0; i<images.size(); i++)
             {
                 DiffusionSignalModel<double>* signalModel;
                 if (i<m_FiberModels.size())
                     signalModel = m_FiberModels.at(i);
                 else
                     signalModel = m_NonFiberModels.at(i-m_FiberModels.size());
 
                 SliceType::Pointer slice = SliceType::New();
                 slice->SetLargestPossibleRegion( sliceRegion );
                 slice->SetBufferedRegion( sliceRegion );
                 slice->SetRequestedRegion( sliceRegion );
                 slice->SetSpacing(sliceSpacing);
                 slice->Allocate();
                 slice->FillBuffer(0.0);
 
                 // extract slice from channel g
                 for (int y=0; y<images.at(0)->GetLargestPossibleRegion().GetSize(1); y++)
                     for (int x=0; x<images.at(0)->GetLargestPossibleRegion().GetSize(0); x++)
                     {
                         SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
                         DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
 
                         slice->SetPixel(index2D, images.at(i)->GetPixel(index3D)[g]);
 
                         if (fMap.IsNotNull() && i==0)
                             fMap->SetPixel(index2D, m_FrequencyMap->GetPixel(index3D));
                     }
 
                 compartmentSlices.push_back(slice);
                 t2Vector.push_back(signalModel->GetT2());
             }
 
             // create k-sapce (inverse fourier transform slices)
             itk::Size<2> outSize; outSize.SetElement(0, m_ImageRegion.GetSize(0)); outSize.SetElement(1, m_ImageRegion.GetSize(1));
             itk::KspaceImageFilter< SliceType::PixelType >::Pointer idft = itk::KspaceImageFilter< SliceType::PixelType >::New();
             idft->SetCompartmentImages(compartmentSlices);
             idft->SetT2(t2Vector);
             idft->SetkOffset(m_kOffset);
             idft->SettLine(m_tLine);
             idft->SetTE(m_TE);
             idft->SetTinhom(m_tInhom);
             idft->SetSimulateRelaxation(m_SimulateRelaxation);
             idft->SetSimulateEddyCurrents(m_SimulateEddyCurrents);
             idft->SetEddyGradientMagnitude(m_EddyGradientStrength);
             idft->SetZ((double)z-(double)images.at(0)->GetLargestPossibleRegion().GetSize(2)/2.0);
             idft->SetDirectionMatrix(transform);
             idft->SetDiffusionGradientDirection(m_FiberModels.at(0)->GetGradientDirection(g));
             idft->SetFrequencyMap(fMap);
             idft->SetSignalScale(m_SignalScale);
             idft->SetOutSize(outSize);
             idft->Update();
 
             ComplexSliceType::Pointer fSlice;
             fSlice = idft->GetOutput();
 
             for (int i=0; i<m_KspaceArtifacts.size(); i++)
                 fSlice = m_KspaceArtifacts.at(i)->AddArtifact(fSlice);
 
             // fourier transform slice
             SliceType::Pointer newSlice;
             itk::DftImageFilter< SliceType::PixelType >::Pointer dft = itk::DftImageFilter< SliceType::PixelType >::New();
             dft->SetInput(fSlice);
             dft->Update();
             newSlice = dft->GetOutput();
 
             // put slice back into channel g
             for (int y=0; y<fSlice->GetLargestPossibleRegion().GetSize(1); y++)
                 for (int x=0; x<fSlice->GetLargestPossibleRegion().GetSize(0); x++)
                 {
                     DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
                     SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
 
                     DoubleDwiType::PixelType pix3D = newImage->GetPixel(index3D);
                     pix3D[g] = newSlice->GetPixel(index2D);
                     newImage->SetPixel(index3D, pix3D);
                 }
 
             ++disp;
         }
     return newImage;
 }
 
 //template< class PixelType >
 //TractsToDWIImageFilter< PixelType >::ComplexSliceType::Pointer TractsToDWIImageFilter< PixelType >::RearrangeSlice(ComplexSliceType::Pointer slice)
 //{
 //    ImageRegion<2> region = slice->GetLargestPossibleRegion();
 //    ComplexSliceType::Pointer rearrangedSlice = ComplexSliceType::New();
 //    rearrangedSlice->SetLargestPossibleRegion( region );
 //    rearrangedSlice->SetBufferedRegion( region );
 //    rearrangedSlice->SetRequestedRegion( region );
 //    rearrangedSlice->Allocate();
 
 //    int xHalf = region.GetSize(0)/2;
 //    int yHalf = region.GetSize(1)/2;
 
 //    for (int y=0; y<region.GetSize(1); y++)
 //        for (int x=0; x<region.GetSize(0); x++)
 //        {
 //            SliceType::IndexType idx;
 //            idx[0]=x; idx[1]=y;
 //            vcl_complex< double > pix = slice->GetPixel(idx);
 
 //            if( idx[0] <  xHalf )
 //                idx[0] = idx[0] + xHalf;
 //            else
 //                idx[0] = idx[0] - xHalf;
 
 //            if( idx[1] <  yHalf )
 //                idx[1] = idx[1] + yHalf;
 //            else
 //                idx[1] = idx[1] - yHalf;
 
 //            rearrangedSlice->SetPixel(idx, pix);
 //        }
 
 //    return rearrangedSlice;
 //}
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::GenerateData()
 {
     // check input data
     if (m_FiberBundle.IsNull())
         itkExceptionMacro("Input fiber bundle is NULL!");
 
     int numFibers = m_FiberBundle->GetNumFibers();
     if (numFibers<=0)
         itkExceptionMacro("Input fiber bundle contains no fibers!");
 
     if (m_FiberModels.empty())
         itkExceptionMacro("No diffusion model for fiber compartments defined!");
 
     if (m_NonFiberModels.empty())
         itkExceptionMacro("No diffusion model for non-fiber compartments defined!");
 
     int baselineIndex = m_FiberModels[0]->GetFirstBaselineIndex();
     if (baselineIndex<0)
         itkExceptionMacro("No baseline index found!");
 
     // check k-space undersampling
     if (m_Upsampling<1)
         m_Upsampling = 1;
 
     if (m_TissueMask.IsNotNull())
     {
         // use input tissue mask
         m_Spacing = m_TissueMask->GetSpacing();
         m_Origin = m_TissueMask->GetOrigin();
         m_DirectionMatrix = m_TissueMask->GetDirection();
         m_ImageRegion = m_TissueMask->GetLargestPossibleRegion();
 
         if (m_Upsampling>1.00001)
         {
             MITK_INFO << "Adding ringing artifacts. Image upsampling factor: " << m_Upsampling;
             ImageRegion<3> region = m_ImageRegion;
             region.SetSize(0, m_ImageRegion.GetSize(0)*m_Upsampling);
             region.SetSize(1, m_ImageRegion.GetSize(1)*m_Upsampling);
             itk::Vector<double> spacing = m_Spacing;
             spacing[0] /= m_Upsampling;
             spacing[1] /= m_Upsampling;
             itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::Pointer rescaler = itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::New();
             rescaler->SetInput(0,m_TissueMask);
             rescaler->SetOutputMaximum(100);
             rescaler->SetOutputMinimum(0);
             rescaler->Update();
 
             itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::Pointer resampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
             resampler->SetInput(rescaler->GetOutput());
             resampler->SetOutputParametersFromImage(m_TissueMask);
             resampler->SetSize(region.GetSize());
             resampler->SetOutputSpacing(spacing);
             resampler->Update();
             m_TissueMask = resampler->GetOutput();
         }
         MITK_INFO << "Using tissue mask";
     }
 
     // initialize output dwi image
     typename OutputImageType::Pointer outImage = OutputImageType::New();
     outImage->SetSpacing( m_Spacing );
     outImage->SetOrigin( m_Origin );
     outImage->SetDirection( m_DirectionMatrix );
     outImage->SetLargestPossibleRegion( m_ImageRegion );
     outImage->SetBufferedRegion( m_ImageRegion );
     outImage->SetRequestedRegion( m_ImageRegion );
     outImage->SetVectorLength( m_FiberModels[0]->GetNumGradients() );
     outImage->Allocate();
     typename OutputImageType::PixelType temp;
     temp.SetSize(m_FiberModels[0]->GetNumGradients());
     temp.Fill(0.0);
     outImage->FillBuffer(temp);
 
     // is input slize size a power of two?
     int x=m_ImageRegion.GetSize(0); int y=m_ImageRegion.GetSize(1);
     if ( x%2 == 1 )
         x += 1;
     if ( y%2 == 1 )
         y += 1;
 
     // if not, adjust size and dimension (needed for FFT); zero-padding
     if (x!=m_ImageRegion.GetSize(0))
         m_ImageRegion.SetSize(0, x);
     if (y!=m_ImageRegion.GetSize(1))
         m_ImageRegion.SetSize(1, y);
 
     // apply undersampling to image parameters
     m_UpsampledSpacing = m_Spacing;
     m_UpsampledImageRegion = m_ImageRegion;
     m_UpsampledSpacing[0] /= m_Upsampling;
     m_UpsampledSpacing[1] /= m_Upsampling;
     m_UpsampledImageRegion.SetSize(0, m_ImageRegion.GetSize()[0]*m_Upsampling);
     m_UpsampledImageRegion.SetSize(1, m_ImageRegion.GetSize()[1]*m_Upsampling);
 
     // everything from here on is using the upsampled image parameters!!!
     if (m_TissueMask.IsNull())
     {
         m_TissueMask = ItkUcharImgType::New();
         m_TissueMask->SetSpacing( m_UpsampledSpacing );
         m_TissueMask->SetOrigin( m_Origin );
         m_TissueMask->SetDirection( m_DirectionMatrix );
         m_TissueMask->SetLargestPossibleRegion( m_UpsampledImageRegion );
         m_TissueMask->SetBufferedRegion( m_UpsampledImageRegion );
         m_TissueMask->SetRequestedRegion( m_UpsampledImageRegion );
         m_TissueMask->Allocate();
         m_TissueMask->FillBuffer(1);
     }
 
     // resample frequency map
     if (m_FrequencyMap.IsNotNull())
     {
         itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::Pointer resampler = itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
         resampler->SetInput(m_FrequencyMap);
         resampler->SetOutputParametersFromImage(m_FrequencyMap);
         resampler->SetSize(m_UpsampledImageRegion.GetSize());
         resampler->SetOutputSpacing(m_UpsampledSpacing);
         resampler->Update();
         m_FrequencyMap = resampler->GetOutput();
     }
 
     // initialize volume fraction images
     m_VolumeFractions.clear();
     for (int i=0; i<m_FiberModels.size()+m_NonFiberModels.size(); i++)
     {
         ItkDoubleImgType::Pointer tempimg = ItkDoubleImgType::New();
         tempimg->SetSpacing( m_UpsampledSpacing );
         tempimg->SetOrigin( m_Origin );
         tempimg->SetDirection( m_DirectionMatrix );
         tempimg->SetLargestPossibleRegion( m_UpsampledImageRegion );
         tempimg->SetBufferedRegion( m_UpsampledImageRegion );
         tempimg->SetRequestedRegion( m_UpsampledImageRegion );
         tempimg->Allocate();
         tempimg->FillBuffer(0);
         m_VolumeFractions.push_back(tempimg);
     }
 
     // resample fiber bundle for sufficient voxel coverage
     double segmentVolume = 0.0001;
     float minSpacing = 1;
     if(m_UpsampledSpacing[0]<m_UpsampledSpacing[1] && m_UpsampledSpacing[0]<m_UpsampledSpacing[2])
         minSpacing = m_UpsampledSpacing[0];
     else if (m_UpsampledSpacing[1] < m_UpsampledSpacing[2])
         minSpacing = m_UpsampledSpacing[1];
     else
         minSpacing = m_UpsampledSpacing[2];
     FiberBundleType fiberBundle = m_FiberBundle->GetDeepCopy();
     fiberBundle->ResampleFibers(minSpacing/m_VolumeAccuracy);
     double mmRadius = m_FiberRadius/1000;
     if (mmRadius>0)
         segmentVolume = M_PI*mmRadius*mmRadius*minSpacing/m_VolumeAccuracy;
 
     // generate double images to work with because we don't want to lose precision
     // we use a separate image for each compartment model
     std::vector< DoubleDwiType::Pointer > compartments;
     for (int i=0; i<m_FiberModels.size()+m_NonFiberModels.size(); i++)
     {
         DoubleDwiType::Pointer doubleDwi = DoubleDwiType::New();
         doubleDwi->SetSpacing( m_UpsampledSpacing );
         doubleDwi->SetOrigin( m_Origin );
         doubleDwi->SetDirection( m_DirectionMatrix );
         doubleDwi->SetLargestPossibleRegion( m_UpsampledImageRegion );
         doubleDwi->SetBufferedRegion( m_UpsampledImageRegion );
         doubleDwi->SetRequestedRegion( m_UpsampledImageRegion );
         doubleDwi->SetVectorLength( m_FiberModels[0]->GetNumGradients() );
         doubleDwi->Allocate();
         DoubleDwiType::PixelType pix;
         pix.SetSize(m_FiberModels[0]->GetNumGradients());
         pix.Fill(0.0);
         doubleDwi->FillBuffer(pix);
         compartments.push_back(doubleDwi);
     }
 
     double interpFact = 2*atan(-0.5*m_InterpolationShrink);
     double maxVolume = 0;
 
     MITK_INFO << "Generating signal of " << m_FiberModels.size() << " fiber compartments";
     vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
     boost::progress_display disp(numFibers);
     for( int i=0; i<numFibers; i++ )
     {
         vtkCell* cell = fiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (numPoints<2)
             continue;
 
         for( int j=0; j<numPoints; j++)
         {
             double* temp = points->GetPoint(j);
             itk::Point<float, 3> vertex = GetItkPoint(temp);
             itk::Vector<double> v = GetItkVector(temp);
 
             itk::Vector<double, 3> dir(3);
             if (j<numPoints-1)
                 dir = GetItkVector(points->GetPoint(j+1))-v;
             else
                 dir = v-GetItkVector(points->GetPoint(j-1));
 
             itk::Index<3> idx;
             itk::ContinuousIndex<float, 3> contIndex;
             m_TissueMask->TransformPhysicalPointToIndex(vertex, idx);
             m_TissueMask->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
             if (!m_UseInterpolation)    // use nearest neighbour interpolation
             {
                 if (!m_TissueMask->GetLargestPossibleRegion().IsInside(idx) || m_TissueMask->GetPixel(idx)<=0)
                     continue;
 
                 // generate signal for each fiber compartment
                 for (int k=0; k<m_FiberModels.size(); k++)
                 {
                     DoubleDwiType::Pointer doubleDwi = compartments.at(k);
                     m_FiberModels[k]->SetFiberDirection(dir);
                     DoubleDwiType::PixelType pix = doubleDwi->GetPixel(idx);
                     pix += segmentVolume*m_FiberModels[k]->SimulateMeasurement();
                     doubleDwi->SetPixel(idx, pix );
                     if (pix[baselineIndex]>maxVolume)
                         maxVolume = pix[baselineIndex];
                 }
 
                 continue;
             }
 
             double frac_x = contIndex[0] - idx[0];
             double frac_y = contIndex[1] - idx[1];
             double frac_z = contIndex[2] - idx[2];
             if (frac_x<0)
             {
                 idx[0] -= 1;
                 frac_x += 1;
             }
             if (frac_y<0)
             {
                 idx[1] -= 1;
                 frac_y += 1;
             }
             if (frac_z<0)
             {
                 idx[2] -= 1;
                 frac_z += 1;
             }
 
             frac_x = atan((0.5-frac_x)*m_InterpolationShrink)/interpFact + 0.5;
             frac_y = atan((0.5-frac_y)*m_InterpolationShrink)/interpFact + 0.5;
             frac_z = atan((0.5-frac_z)*m_InterpolationShrink)/interpFact + 0.5;
 
             // use trilinear interpolation
             itk::Index<3> newIdx;
             for (int x=0; x<2; x++)
             {
                 frac_x = 1-frac_x;
                 for (int y=0; y<2; y++)
                 {
                     frac_y = 1-frac_y;
                     for (int z=0; z<2; z++)
                     {
                         frac_z = 1-frac_z;
 
                         newIdx[0] = idx[0]+x;
                         newIdx[1] = idx[1]+y;
                         newIdx[2] = idx[2]+z;
 
                         double frac = frac_x*frac_y*frac_z;
 
                         // is position valid?
                         if (!m_TissueMask->GetLargestPossibleRegion().IsInside(newIdx) || m_TissueMask->GetPixel(newIdx)<=0)
                             continue;
 
                         // generate signal for each fiber compartment
                         for (int k=0; k<m_FiberModels.size(); k++)
                         {
                             DoubleDwiType::Pointer doubleDwi = compartments.at(k);
                             m_FiberModels[k]->SetFiberDirection(dir);
                             DoubleDwiType::PixelType pix = doubleDwi->GetPixel(newIdx);
                             pix += segmentVolume*frac*m_FiberModels[k]->SimulateMeasurement();
                             doubleDwi->SetPixel(newIdx, pix );
                             if (pix[baselineIndex]>maxVolume)
                                 maxVolume = pix[baselineIndex];
                         }
                     }
                 }
             }
         }
         ++disp;
     }
 
     MITK_INFO << "Generating signal of " << m_NonFiberModels.size() << " non-fiber compartments";
     ImageRegionIterator<ItkUcharImgType> it3(m_TissueMask, m_TissueMask->GetLargestPossibleRegion());
     boost::progress_display disp3(m_TissueMask->GetLargestPossibleRegion().GetNumberOfPixels());
     double voxelVolume = m_UpsampledSpacing[0]*m_UpsampledSpacing[1]*m_UpsampledSpacing[2];
 
     double fact = 1;
     if (m_FiberRadius<0.0001)
         fact = voxelVolume/maxVolume;
 
     while(!it3.IsAtEnd())
     {
         DoubleDwiType::IndexType index = it3.GetIndex();
 
         if (it3.Get()>0)
         {
             // get fiber volume fraction
             DoubleDwiType::Pointer fiberDwi = compartments.at(0);
             DoubleDwiType::PixelType fiberPix = fiberDwi->GetPixel(index); // intra axonal compartment
             if (fact>1) // auto scale intra-axonal if no fiber radius is specified
             {
                 fiberPix *= fact;
                 fiberDwi->SetPixel(index, fiberPix);
             }
             double f = fiberPix[baselineIndex];
 
             if (f>voxelVolume || f>0 && m_EnforcePureFiberVoxels)  // more fiber than space in voxel?
             {
                 fiberDwi->SetPixel(index, fiberPix*voxelVolume/f);
 
                 for (int i=1; i<m_FiberModels.size(); i++)
                 {
                     DoubleDwiType::PixelType pix; pix.Fill(0.0);
                     compartments.at(i)->SetPixel(index, pix);
                     m_VolumeFractions.at(i)->SetPixel(index, 1);
                 }
             }
             else
             {
                 m_VolumeFractions.at(0)->SetPixel(index, f);
 
                 double nonf = voxelVolume-f;    // non-fiber volume
                 double inter = 0;
                 if (m_FiberModels.size()>1)
                     inter = nonf * f/voxelVolume;   // intra-axonal fraction of non fiber compartment scales linearly with f
                 double other = nonf - inter;        // rest of compartment
                 double singleinter = inter/(m_FiberModels.size()-1);
 
                 // adjust non-fiber and intra-axonal signal
                 for (int i=1; i<m_FiberModels.size(); i++)
                 {
                     DoubleDwiType::Pointer doubleDwi = compartments.at(i);
                     DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
                     if (pix[baselineIndex]>0)
                         pix /= pix[baselineIndex];
                     pix *= singleinter;
                     doubleDwi->SetPixel(index, pix);
                     m_VolumeFractions.at(i)->SetPixel(index, singleinter/voxelVolume);
                 }
                 for (int i=0; i<m_NonFiberModels.size(); i++)
                 {
                     DoubleDwiType::Pointer doubleDwi = compartments.at(i+m_FiberModels.size());
                     DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index) + m_NonFiberModels[i]->SimulateMeasurement()*other*m_NonFiberModels[i]->GetWeight();
                     doubleDwi->SetPixel(index, pix);
                     m_VolumeFractions.at(i+m_FiberModels.size())->SetPixel(index, other/voxelVolume*m_NonFiberModels[i]->GetWeight());
                 }
             }
         }
         ++it3;
         ++disp3;
     }
 
     // do k-space stuff
     DoubleDwiType::Pointer doubleOutImage;
     if (m_FrequencyMap.IsNotNull() || !m_KspaceArtifacts.empty() || m_kOffset>0 || m_SimulateRelaxation || m_SimulateEddyCurrents || m_Upsampling>1.00001)
     {
         MITK_INFO << "Adjusting complex signal";
         doubleOutImage = DoKspaceStuff(compartments);
         m_SignalScale = 1;
     }
     else
     {
         MITK_INFO << "Summing compartments";
         doubleOutImage = compartments.at(0);
 
         for (int i=1; i<compartments.size(); i++)
         {
             itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::Pointer adder = itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::New();
             adder->SetInput1(doubleOutImage);
             adder->SetInput2(compartments.at(i));
             adder->Update();
             doubleOutImage = adder->GetOutput();
         }
     }
 
     MITK_INFO << "Finalizing image";
     unsigned int window = 0;
     unsigned int min = itk::NumericTraits<unsigned int>::max();
     ImageRegionIterator<OutputImageType> it4 (outImage, outImage->GetLargestPossibleRegion());
     DoubleDwiType::PixelType signal; signal.SetSize(m_FiberModels[0]->GetNumGradients());
     boost::progress_display disp4(outImage->GetLargestPossibleRegion().GetNumberOfPixels());
     while(!it4.IsAtEnd())
     {
         ++disp4;
         typename OutputImageType::IndexType index = it4.GetIndex();
         signal = doubleOutImage->GetPixel(index)*m_SignalScale;
 
         if (m_NoiseModel->GetNoiseVariance() > 0)
         {
             DoubleDwiType::PixelType accu = signal; accu.Fill(0.0);
             for (int i=0; i<m_NumberOfRepetitions; i++)
             {
                 DoubleDwiType::PixelType temp = signal;
                 m_NoiseModel->AddNoise(temp);
                 accu += temp;
             }
             signal = accu/m_NumberOfRepetitions;
         }
 
         for (int i=0; i<signal.Size(); i++)
         {
             if (signal[i]>0)
                 signal[i] = floor(signal[i]+0.5);
             else
                 signal[i] = ceil(signal[i]-0.5);
 
             if (!m_FiberModels.at(0)->IsBaselineIndex(i) && signal[i]>window)
                 window = signal[i];
             if (!m_FiberModels.at(0)->IsBaselineIndex(i) && signal[i]<min)
                 min = signal[i];
         }
         it4.Set(signal);
         ++it4;
     }
     window -= min;
     unsigned int level = window/2 + min;
     m_LevelWindow.SetLevelWindow(level, window);
     this->SetNthOutput(0, outImage);
 }
 
 template< class PixelType >
 itk::Point<float, 3> TractsToDWIImageFilter< PixelType >::GetItkPoint(double point[3])
 {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 template< class PixelType >
 itk::Vector<double, 3> TractsToDWIImageFilter< PixelType >::GetItkVector(double point[3])
 {
     itk::Vector<double, 3> itkVector;
     itkVector[0] = point[0];
     itkVector[1] = point[1];
     itkVector[2] = point[2];
     return itkVector;
 }
 
 template< class PixelType >
 vnl_vector_fixed<double, 3> TractsToDWIImageFilter< PixelType >::GetVnlVector(double point[3])
 {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = point[0];
     vnlVector[1] = point[1];
     vnlVector[2] = point[2];
     return vnlVector;
 }
 
 template< class PixelType >
 vnl_vector_fixed<double, 3> TractsToDWIImageFilter< PixelType >::GetVnlVector(Vector<float,3>& vector)
 {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = vector[0];
     vnlVector[1] = vector[1];
     vnlVector[2] = vector[2];
     return vnlVector;
 }
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.cpp
index dcd21e5dd0..b2dac9cf49 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToFiberEndingsImageFilter.cpp
@@ -1,162 +1,160 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #include "itkTractsToFiberEndingsImageFilter.h"
 
 // VTK
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#endif
+#include <boost/progress.hpp>
 
 namespace itk{
 
   template< class OutputImageType >
   TractsToFiberEndingsImageFilter< OutputImageType >::TractsToFiberEndingsImageFilter()
     : m_InvertImage(false)
     , m_UpsamplingFactor(1)
     , m_InputImage(NULL)
     , m_UseImageGeometry(false)
     , m_BinaryOutput(false)
   {
 
   }
 
   template< class OutputImageType >
   TractsToFiberEndingsImageFilter< OutputImageType >::~TractsToFiberEndingsImageFilter()
   {
   }
 
   template< class OutputImageType >
   itk::Point<float, 3> TractsToFiberEndingsImageFilter< OutputImageType >::GetItkPoint(double point[3])
   {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
   }
 
   template< class OutputImageType >
   void TractsToFiberEndingsImageFilter< OutputImageType >::GenerateData()
   {
     // generate upsampled image
     mitk::Geometry3D::Pointer geometry = m_FiberBundle->GetGeometry();
     typename OutputImageType::Pointer outImage = this->GetOutput();
 
     // calculate new image parameters
     itk::Vector<double, 3> newSpacing;
     mitk::Point3D newOrigin;
     itk::Matrix<double, 3, 3> newDirection;
     ImageRegion<3> upsampledRegion;
     if (m_UseImageGeometry && !m_InputImage.IsNull())
     {
       newSpacing = m_InputImage->GetSpacing()/m_UpsamplingFactor;
       upsampledRegion = m_InputImage->GetLargestPossibleRegion();
       newOrigin = m_InputImage->GetOrigin();
       typename OutputImageType::RegionType::SizeType size = upsampledRegion.GetSize();
       size[0] *= m_UpsamplingFactor;
       size[1] *= m_UpsamplingFactor;
       size[2] *= m_UpsamplingFactor;
       upsampledRegion.SetSize(size);
       newDirection = m_InputImage->GetDirection();
     }
     else
     {
       newSpacing = geometry->GetSpacing()/m_UpsamplingFactor;
       newOrigin = geometry->GetOrigin();
       mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
       newOrigin[0] += bounds.GetElement(0);
       newOrigin[1] += bounds.GetElement(2);
       newOrigin[2] += bounds.GetElement(4);
 
       for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
           newDirection[j][i] = geometry->GetMatrixColumn(i)[j];
       upsampledRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
       upsampledRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
       upsampledRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
     }
     typename OutputImageType::RegionType::SizeType upsampledSize = upsampledRegion.GetSize();
 
     // apply new image parameters
     outImage->SetSpacing( newSpacing );
     outImage->SetOrigin( newOrigin );
     outImage->SetDirection( newDirection );
     outImage->SetRegions( upsampledRegion );
     outImage->Allocate();
 
     int w = upsampledSize[0];
     int h = upsampledSize[1];
     int d = upsampledSize[2];
 
     // set/initialize output
     OutPixelType* outImageBufferPointer = (OutPixelType*)outImage->GetBufferPointer();
     for (int i=0; i<w*h*d; i++)
       outImageBufferPointer[i] = 0;
 
     // resample fiber bundle
     float minSpacing = 1;
     if(newSpacing[0]<newSpacing[1] && newSpacing[0]<newSpacing[2])
         minSpacing = newSpacing[0];
     else if (newSpacing[1] < newSpacing[2])
         minSpacing = newSpacing[1];
     else
         minSpacing = newSpacing[2];
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
     vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
     vLines->InitTraversal();
 
     int numFibers = m_FiberBundle->GetNumFibers();
     boost::progress_display disp(numFibers);
     for( int i=0; i<numFibers; i++ )
     {
         ++disp;
       vtkIdType   numPoints(0);
       vtkIdType*  points(NULL);
       vLines->GetNextCell ( numPoints, points );
 
       // fill output image
       if (numPoints>0)
       {
         itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[0]));
         itk::Index<3> index;
         outImage->TransformPhysicalPointToIndex(vertex, index);
         if (m_BinaryOutput)
             outImage->SetPixel(index, 1);
         else
             outImage->SetPixel(index, outImage->GetPixel(index)+1);
       }
 
       if (numPoints>2)
       {
         itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[numPoints-1]));
         itk::Index<3> index;
         outImage->TransformPhysicalPointToIndex(vertex, index);
         if (m_BinaryOutput)
             outImage->SetPixel(index, 1);
         else
             outImage->SetPixel(index, outImage->GetPixel(index)+1);
       }
     }
 
     if (m_InvertImage)
       for (int i=0; i<w*h*d; i++)
         outImageBufferPointer[i] = 1-outImageBufferPointer[i];
   }
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.cpp
index 32222fcfc1..60fad63e14 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToRgbaImageFilter.cpp
@@ -1,288 +1,286 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #include "itkTractsToRgbaImageFilter.h"
 
 // VTK
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 
 // misc
 #include <math.h>
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#endif
+#include <boost/progress.hpp>
 
 namespace itk{
 
   template< class OutputImageType >
   TractsToRgbaImageFilter< OutputImageType >::TractsToRgbaImageFilter()
     : m_UpsamplingFactor(1)
     , m_InputImage(NULL)
     , m_UseImageGeometry(false)
   {
 
   }
 
   template< class OutputImageType >
   TractsToRgbaImageFilter< OutputImageType >::~TractsToRgbaImageFilter()
   {
   }
 
   template< class OutputImageType >
   itk::Point<float, 3> TractsToRgbaImageFilter< OutputImageType >::GetItkPoint(double point[3])
   {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
   }
 
   template< class OutputImageType >
   void TractsToRgbaImageFilter< OutputImageType >::GenerateData()
   {
     if(&typeid(OutPixelType) != &typeid(itk::RGBAPixel<unsigned char>))
       return;
 
     // generate upsampled image
     mitk::Geometry3D::Pointer geometry = m_FiberBundle->GetGeometry();
     typename OutputImageType::Pointer outImage = this->GetOutput();
 
     // calculate new image parameters
     itk::Vector<double,3> newSpacing;
     mitk::Point3D newOrigin;
     itk::Matrix<double, 3, 3> newDirection;
     ImageRegion<3> upsampledRegion;
     if (m_UseImageGeometry && !m_InputImage.IsNull())
     {
       newSpacing = m_InputImage->GetSpacing()/m_UpsamplingFactor;
       upsampledRegion = m_InputImage->GetLargestPossibleRegion();
       newOrigin = m_InputImage->GetOrigin();
       typename OutputImageType::RegionType::SizeType size = upsampledRegion.GetSize();
       size[0] *= m_UpsamplingFactor;
       size[1] *= m_UpsamplingFactor;
       size[2] *= m_UpsamplingFactor;
       upsampledRegion.SetSize(size);
       newDirection = m_InputImage->GetDirection();
     }
     else
     {
       newSpacing = geometry->GetSpacing()/m_UpsamplingFactor;
       newOrigin = geometry->GetOrigin();
       mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
       newOrigin[0] += bounds.GetElement(0);
       newOrigin[1] += bounds.GetElement(2);
       newOrigin[2] += bounds.GetElement(4);
 
       for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
           newDirection[j][i] = geometry->GetMatrixColumn(i)[j];
       upsampledRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
       upsampledRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
       upsampledRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
     }
     typename OutputImageType::RegionType::SizeType upsampledSize = upsampledRegion.GetSize();
 
     // apply new image parameters
     outImage->SetSpacing( newSpacing );
     outImage->SetOrigin( newOrigin );
     outImage->SetDirection( newDirection );
     outImage->SetRegions( upsampledRegion );
     outImage->Allocate();
 
     int w = upsampledSize[0];
     int h = upsampledSize[1];
     int d = upsampledSize[2];
 
     // set/initialize output
     unsigned char* outImageBufferPointer = (unsigned char*)outImage->GetBufferPointer();
     float* buffer = new float[w*h*d*4];
     for (int i=0; i<w*h*d*4; i++)
       buffer[i] = 0;
 
     // resample fiber bundle
     float minSpacing = 1;
     if(newSpacing[0]<newSpacing[1] && newSpacing[0]<newSpacing[2])
         minSpacing = newSpacing[0];
     else if (newSpacing[1] < newSpacing[2])
         minSpacing = newSpacing[1];
     else
         minSpacing = newSpacing[2];
 
     m_FiberBundle = m_FiberBundle->GetDeepCopy();
     m_FiberBundle->ResampleFibers(minSpacing);
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
     vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
     vLines->InitTraversal();
 
     int numFibers = m_FiberBundle->GetNumFibers();
     boost::progress_display disp(numFibers);
     for( int i=0; i<numFibers; i++ )
     {
       ++disp;
       vtkIdType   numPoints(0);
       vtkIdType*  points(NULL);
       vLines->GetNextCell ( numPoints, points );
 
       // calc directions (which are used as weights)
       std::list< itk::Point<float, 3> > rgbweights;
       std::list<float> intensities;
 
       for( int j=0; j<numPoints-1; j++)
       {
 
         itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[j]));
         itk::Point<float, 3> vertexPost = GetItkPoint(fiberPolyData->GetPoint(points[j+1]));
 
         itk::Point<float, 3> dir;
         dir[0] = fabs((vertexPost[0] - vertex[0]) * outImage->GetSpacing()[0]);
         dir[1] = fabs((vertexPost[1] - vertex[1]) * outImage->GetSpacing()[1]);
         dir[2] = fabs((vertexPost[2] - vertex[2]) * outImage->GetSpacing()[2]);
 
         rgbweights.push_back(dir);
 
         float intensity = sqrt(dir[0]*dir[0]+dir[1]*dir[1]+dir[2]*dir[2]);
         intensities.push_back(intensity);
 
         // last point gets same as previous one
         if(j==numPoints-2)
         {
           rgbweights.push_back(dir);
           intensities.push_back(intensity);
         }
       }
 
       // fill output image
       for( int j=0; j<numPoints; j++)
       {
         itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[j]));
         itk::Index<3> index;
         itk::ContinuousIndex<float, 3> contIndex;
         outImage->TransformPhysicalPointToIndex(vertex, index);
         outImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
         float frac_x = contIndex[0] - index[0];
         float frac_y = contIndex[1] - index[1];
         float frac_z = contIndex[2] - index[2];
 
         int px = index[0];
         if (frac_x<0)
         {
           px -= 1;
           frac_x += 1;
         }
 
         int py = index[1];
         if (frac_y<0)
         {
           py -= 1;
           frac_y += 1;
         }
 
         int pz = index[2];
         if (frac_z<0)
         {
           pz -= 1;
           frac_z += 1;
         }
 
         // int coordinates inside image?
         if (px < 0 || px >= w-1)
           continue;
         if (py < 0 || py >= h-1)
           continue;
         if (pz < 0 || pz >= d-1)
           continue;
 
         float scale = 100 * pow((float)m_UpsamplingFactor,3);
         itk::Point<float, 3> rgbweight = rgbweights.front();
         rgbweights.pop_front();
         float intweight = intensities.front();
         intensities.pop_front();
 
         // add to r-channel in output image
         buffer[0+4*( px   + w*(py  + h*pz  ))] += (1-frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[0] * scale;
         buffer[0+4*( px   + w*(py+1+ h*pz  ))] += (1-frac_x)*(  frac_y)*(1-frac_z) * rgbweight[0] * scale;
         buffer[0+4*( px   + w*(py  + h*pz+h))] += (1-frac_x)*(1-frac_y)*(  frac_z) * rgbweight[0] * scale;
         buffer[0+4*( px   + w*(py+1+ h*pz+h))] += (1-frac_x)*(  frac_y)*(  frac_z) * rgbweight[0] * scale;
         buffer[0+4*( px+1 + w*(py  + h*pz  ))] += (  frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[0] * scale;
         buffer[0+4*( px+1 + w*(py  + h*pz+h))] += (  frac_x)*(1-frac_y)*(  frac_z) * rgbweight[0] * scale;
         buffer[0+4*( px+1 + w*(py+1+ h*pz  ))] += (  frac_x)*(  frac_y)*(1-frac_z) * rgbweight[0] * scale;
         buffer[0+4*( px+1 + w*(py+1+ h*pz+h))] += (  frac_x)*(  frac_y)*(  frac_z) * rgbweight[0] * scale;
 
         // add to g-channel in output image
         buffer[1+4*( px   + w*(py  + h*pz  ))] += (1-frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[1] * scale;
         buffer[1+4*( px   + w*(py+1+ h*pz  ))] += (1-frac_x)*(  frac_y)*(1-frac_z) * rgbweight[1] * scale;
         buffer[1+4*( px   + w*(py  + h*pz+h))] += (1-frac_x)*(1-frac_y)*(  frac_z) * rgbweight[1] * scale;
         buffer[1+4*( px   + w*(py+1+ h*pz+h))] += (1-frac_x)*(  frac_y)*(  frac_z) * rgbweight[1] * scale;
         buffer[1+4*( px+1 + w*(py  + h*pz  ))] += (  frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[1] * scale;
         buffer[1+4*( px+1 + w*(py  + h*pz+h))] += (  frac_x)*(1-frac_y)*(  frac_z) * rgbweight[1] * scale;
         buffer[1+4*( px+1 + w*(py+1+ h*pz  ))] += (  frac_x)*(  frac_y)*(1-frac_z) * rgbweight[1] * scale;
         buffer[1+4*( px+1 + w*(py+1+ h*pz+h))] += (  frac_x)*(  frac_y)*(  frac_z) * rgbweight[1] * scale;
 
         // add to b-channel in output image
         buffer[2+4*( px   + w*(py  + h*pz  ))] += (1-frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[2] * scale;
         buffer[2+4*( px   + w*(py+1+ h*pz  ))] += (1-frac_x)*(  frac_y)*(1-frac_z) * rgbweight[2] * scale;
         buffer[2+4*( px   + w*(py  + h*pz+h))] += (1-frac_x)*(1-frac_y)*(  frac_z) * rgbweight[2] * scale;
         buffer[2+4*( px   + w*(py+1+ h*pz+h))] += (1-frac_x)*(  frac_y)*(  frac_z) * rgbweight[2] * scale;
         buffer[2+4*( px+1 + w*(py  + h*pz  ))] += (  frac_x)*(1-frac_y)*(1-frac_z) * rgbweight[2] * scale;
         buffer[2+4*( px+1 + w*(py  + h*pz+h))] += (  frac_x)*(1-frac_y)*(  frac_z) * rgbweight[2] * scale;
         buffer[2+4*( px+1 + w*(py+1+ h*pz  ))] += (  frac_x)*(  frac_y)*(1-frac_z) * rgbweight[2] * scale;
         buffer[2+4*( px+1 + w*(py+1+ h*pz+h))] += (  frac_x)*(  frac_y)*(  frac_z) * rgbweight[2] * scale;
 
         // add to a-channel in output image
         buffer[3+4*( px   + w*(py  + h*pz  ))] += (1-frac_x)*(1-frac_y)*(1-frac_z) * intweight * scale;
         buffer[3+4*( px   + w*(py+1+ h*pz  ))] += (1-frac_x)*(  frac_y)*(1-frac_z) * intweight * scale;
         buffer[3+4*( px   + w*(py  + h*pz+h))] += (1-frac_x)*(1-frac_y)*(  frac_z) * intweight * scale;
         buffer[3+4*( px   + w*(py+1+ h*pz+h))] += (1-frac_x)*(  frac_y)*(  frac_z) * intweight * scale;
         buffer[3+4*( px+1 + w*(py  + h*pz  ))] += (  frac_x)*(1-frac_y)*(1-frac_z) * intweight * scale;
         buffer[3+4*( px+1 + w*(py  + h*pz+h))] += (  frac_x)*(1-frac_y)*(  frac_z) * intweight * scale;
         buffer[3+4*( px+1 + w*(py+1+ h*pz  ))] += (  frac_x)*(  frac_y)*(1-frac_z) * intweight * scale;
         buffer[3+4*( px+1 + w*(py+1+ h*pz+h))] += (  frac_x)*(  frac_y)*(  frac_z) * intweight * scale;
       }
     }
     float maxRgb = 0.000000001;
     float maxInt = 0.000000001;
     int numPix;
 
     numPix = w*h*d*4;
     // calc maxima
     for(int i=0; i<numPix; i++)
     {
       if((i-3)%4 != 0)
       {
         if(buffer[i] > maxRgb)
           maxRgb = buffer[i];
       }
       else
       {
         if(buffer[i] > maxInt)
           maxInt = buffer[i];
       }
     }
 
     // write output, normalized uchar 0..255
     for(int i=0; i<numPix; i++)
     {
       if((i-3)%4 != 0)
         outImageBufferPointer[i] = (unsigned char) (255.0 * buffer[i] / maxRgb);
       else
         outImageBufferPointer[i] = (unsigned char) (255.0 * buffer[i] / maxInt);
     }
   }
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
index 46f902613d..6907da7f64 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
@@ -1,835 +1,833 @@
 #include "itkTractsToVectorImageFilter.h"
 
 // VTK
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 
 // ITK
 #include <itkTimeProbe.h>
 #include <itkImageRegionIterator.h>
 
 // misc
 #define _USE_MATH_DEFINES
 #include <math.h>
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#endif
+#include <boost/progress.hpp>
 
 
 namespace itk{
 
 static bool CompareVectorLengths(const vnl_vector_fixed< double, 3 >& v1, const vnl_vector_fixed< double, 3 >& v2)
 {
     return (v1.magnitude()>v2.magnitude());
 }
 
 template< class PixelType >
 TractsToVectorImageFilter< PixelType >::TractsToVectorImageFilter():
     m_AngularThreshold(0.7),
     m_MaskImage(NULL),
     m_NumDirectionsImage(NULL),
     m_NormalizeVectors(false),
     m_Epsilon(0.999),
     m_UseWorkingCopy(true),
     m_MaxNumDirections(3),
     m_UseTrilinearInterpolation(false),
     m_Thres(0.5)
 {
     this->SetNumberOfRequiredOutputs(1);
 }
 
 
 template< class PixelType >
 TractsToVectorImageFilter< PixelType >::~TractsToVectorImageFilter()
 {
 }
 
 
 template< class PixelType >
 vnl_vector_fixed<double, 3> TractsToVectorImageFilter< PixelType >::GetVnlVector(double point[3])
 {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = point[0];
     vnlVector[1] = point[1];
     vnlVector[2] = point[2];
     return vnlVector;
 }
 
 
 template< class PixelType >
 itk::Point<float, 3> TractsToVectorImageFilter< PixelType >::GetItkPoint(double point[3])
 {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 template< class PixelType >
 void TractsToVectorImageFilter< PixelType >::GenerateData()
 {
     mitk::Geometry3D::Pointer geometry = m_FiberBundle->GetGeometry();
 
     // calculate new image parameters
     itk::Vector<double> spacing;
     itk::Point<double> origin;
     itk::Matrix<double, 3, 3> direction;
     ImageRegion<3> imageRegion;
     if (!m_MaskImage.IsNull())
     {
         spacing = m_MaskImage->GetSpacing();
         imageRegion = m_MaskImage->GetLargestPossibleRegion();
         origin = m_MaskImage->GetOrigin();
         direction = m_MaskImage->GetDirection();
     }
     else
     {
         spacing = geometry->GetSpacing();
         origin = geometry->GetOrigin();
         mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
         origin[0] += bounds.GetElement(0);
         origin[1] += bounds.GetElement(2);
         origin[2] += bounds.GetElement(4);
 
         for (int i=0; i<3; i++)
             for (int j=0; j<3; j++)
                 direction[j][i] = geometry->GetMatrixColumn(i)[j];
         imageRegion.SetSize(0, geometry->GetExtent(0));
         imageRegion.SetSize(1, geometry->GetExtent(1));
         imageRegion.SetSize(2, geometry->GetExtent(2));
 
 
         m_MaskImage = ItkUcharImgType::New();
         m_MaskImage->SetSpacing( spacing );
         m_MaskImage->SetOrigin( origin );
         m_MaskImage->SetDirection( direction );
         m_MaskImage->SetRegions( imageRegion );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
     OutputImageType::RegionType::SizeType outImageSize = imageRegion.GetSize();
     m_OutImageSpacing = m_MaskImage->GetSpacing();
     m_ClusteredDirectionsContainer = ContainerType::New();
 
     // initialize crossings image
     m_CrossingsImage = ItkUcharImgType::New();
     m_CrossingsImage->SetSpacing( spacing );
     m_CrossingsImage->SetOrigin( origin );
     m_CrossingsImage->SetDirection( direction );
     m_CrossingsImage->SetRegions( imageRegion );
     m_CrossingsImage->Allocate();
     m_CrossingsImage->FillBuffer(0);
 
     // initialize num directions image
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( spacing );
     m_NumDirectionsImage->SetOrigin( origin );
     m_NumDirectionsImage->SetDirection( direction );
     m_NumDirectionsImage->SetRegions( imageRegion );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     // resample fiber bundle
     float minSpacing = 1;
     if(m_OutImageSpacing[0]<m_OutImageSpacing[1] && m_OutImageSpacing[0]<m_OutImageSpacing[2])
         minSpacing = m_OutImageSpacing[0];
     else if (m_OutImageSpacing[1] < m_OutImageSpacing[2])
         minSpacing = m_OutImageSpacing[1];
     else
         minSpacing = m_OutImageSpacing[2];
 
     if (m_UseWorkingCopy)
         m_FiberBundle = m_FiberBundle->GetDeepCopy();
 
     // resample fiber bundle for sufficient voxel coverage
     m_FiberBundle->ResampleFibers(minSpacing/10);
 
     // iterate over all fibers
     vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
     vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
     vLines->InitTraversal();
     int numFibers = m_FiberBundle->GetNumFibers();
     itk::TimeProbe clock;
     m_DirectionsContainer = ContainerType::New();
 
     if (m_UseTrilinearInterpolation)
         MITK_INFO << "Generating directions from tractogram (trilinear interpolation)";
     else
         MITK_INFO << "Generating directions from tractogram";
 
     boost::progress_display disp(numFibers);
     for( int i=0; i<numFibers; i++ )
     {
         ++disp;
         clock.Start();
         vtkIdType   numPoints(0);
         vtkIdType*  points(NULL);
         vLines->GetNextCell ( numPoints, points );
         if (numPoints<2)
             continue;
 
         itk::Index<3> index; index.Fill(0);
         itk::ContinuousIndex<float, 3> contIndex;
         vnl_vector_fixed<double, 3> dir, wDir;
         itk::Point<float, 3> worldPos;
         vnl_vector<double> v;
         for( int j=0; j<numPoints-1; j++)
         {
             double* temp = fiberPolyData->GetPoint(points[j]);
             worldPos = GetItkPoint(temp);
             v = GetVnlVector(temp);
 
             dir = GetVnlVector(fiberPolyData->GetPoint(points[j+1]))-v;
             dir.normalize();
 
             m_MaskImage->TransformPhysicalPointToIndex(worldPos, index);
             m_MaskImage->TransformPhysicalPointToContinuousIndex(worldPos, contIndex);
 
             if (m_MaskImage->GetPixel(index)==0)
                 continue;
 
             if (!m_UseTrilinearInterpolation)
             {
                 if (index[0] < 0 || index[0] >= outImageSize[0])
                     continue;
                 if (index[1] < 0 || index[1] >= outImageSize[1])
                     continue;
                 if (index[2] < 0 || index[2] >= outImageSize[2])
                     continue;
 
                 int idx = index[0] + outImageSize[0]*(index[1] + outImageSize[1]*index[2]);
                 DirectionContainerType::Pointer dirCont = DirectionContainerType::New();
                 if (m_DirectionsContainer->IndexExists(idx))
                 {
                     dirCont = m_DirectionsContainer->GetElement(idx);
                     if (dirCont.IsNull())
                     {
                         dirCont = DirectionContainerType::New();
                         dirCont->InsertElement(0, dir);
                         m_DirectionsContainer->InsertElement(idx, dirCont);
                     }
                     else
                         dirCont->InsertElement(dirCont->Size(), dir);
                 }
                 else
                 {
                     dirCont->InsertElement(0, dir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
 
                 continue;
             }
 
             float frac_x = contIndex[0] - index[0];
             float frac_y = contIndex[1] - index[1];
             float frac_z = contIndex[2] - index[2];
 
             if (frac_x<0)
             {
                 index[0] -= 1;
                 frac_x += 1;
             }
             if (frac_y<0)
             {
                 index[1] -= 1;
                 frac_y += 1;
             }
             if (frac_z<0)
             {
                 index[2] -= 1;
                 frac_z += 1;
             }
 
             frac_x = 1-frac_x;
             frac_y = 1-frac_y;
             frac_z = 1-frac_z;
 
             // int coordinates inside image?
             if (index[0] < 0 || index[0] >= outImageSize[0]-1)
                 continue;
             if (index[1] < 0 || index[1] >= outImageSize[1]-1)
                 continue;
             if (index[2] < 0 || index[2] >= outImageSize[2]-1)
                 continue;
 
             DirectionContainerType::Pointer dirCont;
             int idx;
             wDir = dir;
             float weight = (  frac_x)*(  frac_y)*(  frac_z);
             if (weight>m_Thres)
             {
                 wDir *= weight;
                 idx = index[0]   + outImageSize[0]*(index[1]  + outImageSize[1]*index[2]  );
                 dirCont = DirectionContainerType::New();
                 if (m_DirectionsContainer->IndexExists(idx))
                 {
                     dirCont = m_DirectionsContainer->GetElement(idx);
                     if (dirCont.IsNull())
                     {
                         dirCont = DirectionContainerType::New();
                         dirCont->InsertElement(0, wDir);
                         m_DirectionsContainer->InsertElement(idx, dirCont);
                     }
                     else
                         dirCont->InsertElement(dirCont->Size(), wDir);
                 }
                 else
                 {
                     dirCont->InsertElement(0, wDir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
             }
 
             wDir = dir;
             weight = (  frac_x)*(1-frac_y)*(  frac_z);
             if (weight>m_Thres)
             {
                 wDir *= weight;
                 idx = index[0]   + outImageSize[0]*(index[1]+1+ outImageSize[1]*index[2]  );
                 dirCont = DirectionContainerType::New();
                 if (m_DirectionsContainer->IndexExists(idx))
                 {
                     dirCont = m_DirectionsContainer->GetElement(idx);
                     if (dirCont.IsNull())
                     {
                         dirCont = DirectionContainerType::New();
                         dirCont->InsertElement(0, wDir);
                         m_DirectionsContainer->InsertElement(idx, dirCont);
                     }
                     else
                         dirCont->InsertElement(dirCont->Size(), wDir);
                 }
                 else
                 {
                     dirCont->InsertElement(0, wDir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
             }
 
             wDir = dir;
             weight = (  frac_x)*(  frac_y)*(1-frac_z);
             if (weight>m_Thres)
             {
                 wDir *= weight;
                 idx = index[0]   + outImageSize[0]*(index[1]  + outImageSize[1]*index[2]+outImageSize[1]);
                 dirCont = DirectionContainerType::New();
                 if (m_DirectionsContainer->IndexExists(idx))
                 {
                     dirCont = m_DirectionsContainer->GetElement(idx);
                     if (dirCont.IsNull())
                     {
                         dirCont = DirectionContainerType::New();
                         dirCont->InsertElement(0, wDir);
                         m_DirectionsContainer->InsertElement(idx, dirCont);
                     }
                     else
                         dirCont->InsertElement(dirCont->Size(), wDir);
                 }
                 else
                 {
                     dirCont->InsertElement(0, wDir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
             }
 
             wDir = dir;
             weight = (  frac_x)*(1-frac_y)*(1-frac_z);
             if (weight>m_Thres)
             {
                 wDir *= weight;
                 idx = index[0]   + outImageSize[0]*(index[1]+1+ outImageSize[1]*index[2]+outImageSize[1]);
                 dirCont = DirectionContainerType::New();
                 if (m_DirectionsContainer->IndexExists(idx))
                 {
                     dirCont = m_DirectionsContainer->GetElement(idx);
                     if (dirCont.IsNull())
                     {
                         dirCont = DirectionContainerType::New();
                         dirCont->InsertElement(0, wDir);
                         m_DirectionsContainer->InsertElement(idx, dirCont);
                     }
                     else
                         dirCont->InsertElement(dirCont->Size(), wDir);
                 }
                 else
                 {
                     dirCont->InsertElement(0, wDir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
             }
 
             wDir = dir;
             weight = (1-frac_x)*(  frac_y)*(  frac_z);
             if (weight>m_Thres)
             {
                 wDir *= weight;
                 idx = index[0]+1 + outImageSize[0]*(index[1]  + outImageSize[1]*index[2]  );
                 dirCont = DirectionContainerType::New();
                 if (m_DirectionsContainer->IndexExists(idx))
                 {
                     dirCont = m_DirectionsContainer->GetElement(idx);
                     if (dirCont.IsNull())
                     {
                         dirCont = DirectionContainerType::New();
                         dirCont->InsertElement(0, wDir);
                         m_DirectionsContainer->InsertElement(idx, dirCont);
                     }
                     else
                         dirCont->InsertElement(dirCont->Size(), wDir);
                 }
                 else
                 {
                     dirCont->InsertElement(0, wDir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
             }
 
             wDir = dir;
             weight = (1-frac_x)*(  frac_y)*(1-frac_z);
             if (weight>m_Thres)
             {
                 wDir *= weight;
                 idx = index[0]+1 + outImageSize[0]*(index[1]  + outImageSize[1]*index[2]+outImageSize[1]);
                 dirCont = DirectionContainerType::New();
                 if (m_DirectionsContainer->IndexExists(idx))
                 {
                     dirCont = m_DirectionsContainer->GetElement(idx);
                     if (dirCont.IsNull())
                     {
                         dirCont = DirectionContainerType::New();
                         dirCont->InsertElement(0, wDir);
                         m_DirectionsContainer->InsertElement(idx, dirCont);
                     }
                     else
                         dirCont->InsertElement(dirCont->Size(), wDir);
                 }
                 else
                 {
                     dirCont->InsertElement(0, wDir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
             }
 
             wDir = dir;
             weight = (1-frac_x)*(1-frac_y)*(  frac_z);
             if (weight>m_Thres)
             {
                 wDir *= weight;
                 idx = index[0]+1 + outImageSize[0]*(index[1]+1+ outImageSize[1]*index[2]  );
                 dirCont = DirectionContainerType::New();
                 if (m_DirectionsContainer->IndexExists(idx))
                 {
                     dirCont = m_DirectionsContainer->GetElement(idx);
                     if (dirCont.IsNull())
                     {
                         dirCont = DirectionContainerType::New();
                         dirCont->InsertElement(0, wDir);
                         m_DirectionsContainer->InsertElement(idx, dirCont);
                     }
                     else
                         dirCont->InsertElement(dirCont->Size(), wDir);
                 }
                 else
                 {
                     dirCont->InsertElement(0, wDir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
             }
 
             wDir = dir;
             weight = (1-frac_x)*(1-frac_y)*(1-frac_z);
             if (weight>m_Thres)
             {
                 wDir *= weight;
                 idx = index[0]+1 + outImageSize[0]*(index[1]+1+ outImageSize[1]*index[2]+outImageSize[1]);
                 dirCont = DirectionContainerType::New();
                 if (m_DirectionsContainer->IndexExists(idx))
                 {
                     dirCont = m_DirectionsContainer->GetElement(idx);
                     if (dirCont.IsNull())
                     {
                         dirCont = DirectionContainerType::New();
                         dirCont->InsertElement(0, wDir);
                         m_DirectionsContainer->InsertElement(idx, dirCont);
                     }
                     else
                         dirCont->InsertElement(dirCont->Size(), wDir);
                 }
                 else
                 {
                     dirCont->InsertElement(0, wDir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
             }
         }
         clock.Stop();
     }
 
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     itk::ImageRegionIterator<ItkUcharImgType> dirIt(m_NumDirectionsImage, m_NumDirectionsImage->GetLargestPossibleRegion());
     itk::ImageRegionIterator<ItkUcharImgType> crossIt(m_CrossingsImage, m_CrossingsImage->GetLargestPossibleRegion());
 
     m_DirectionImageContainer = DirectionImageContainerType::New();
     int maxNumDirections = 0;
 
     MITK_INFO << "Clustering directions";
     boost::progress_display disp2(outImageSize[0]*outImageSize[1]*outImageSize[2]);
     for(crossIt.GoToBegin(); !crossIt.IsAtEnd(); ++crossIt)
     {
         ++disp2;
         OutputImageType::IndexType index = crossIt.GetIndex();
         int idx = index[0]+(index[1]+index[2]*outImageSize[1])*outImageSize[0];
 
         if (!m_DirectionsContainer->IndexExists(idx))
         {
             ++dirIt;
             continue;
         }
         DirectionContainerType::Pointer dirCont = m_DirectionsContainer->GetElement(idx);
         if (dirCont.IsNull() || index[0] < 0 || index[0] >= outImageSize[0] || index[1] < 0 || index[1] >= outImageSize[1] || index[2] < 0 || index[2] >= outImageSize[2])
         {
             ++dirIt;
             continue;
         }
 
         std::vector< DirectionType > directions;
 
         for (int i=0; i<dirCont->Size(); i++)
             if (dirCont->ElementAt(i).magnitude()>0.0001)
                 directions.push_back(dirCont->ElementAt(i));
 
         if (!directions.empty())
             directions = FastClustering(directions);
 
         std::sort( directions.begin(), directions.end(), CompareVectorLengths );
 
         if ( directions.size() > maxNumDirections )
         {
             for (int i=maxNumDirections; i<std::min((int)directions.size(), m_MaxNumDirections); i++)
             {
                 ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
                 directionImage->SetSpacing( spacing );
                 directionImage->SetOrigin( origin );
                 directionImage->SetDirection( direction );
                 directionImage->SetRegions( imageRegion );
                 directionImage->Allocate();
                 Vector< float, 3 > nullVec; nullVec.Fill(0.0);
                 directionImage->FillBuffer(nullVec);
                 m_DirectionImageContainer->InsertElement(i, directionImage);
             }
             maxNumDirections = std::min((int)directions.size(), m_MaxNumDirections);
         }
 
         int numDir = directions.size();
         if (numDir>m_MaxNumDirections)
             numDir = m_MaxNumDirections;
 
         for (int i=0; i<numDir; i++)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             itk::ContinuousIndex<float, 3> center;
             center[0] = index[0];
             center[1] = index[1];
             center[2] = index[2];
             itk::Point<float> worldCenter;
             m_MaskImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
 
             DirectionType dir = m_MaskImage->GetDirection()*directions.at(i);
 
             // set direction image pixel
             ItkDirectionImageType::Pointer directionImage = m_DirectionImageContainer->GetElement(i);
             Vector< float, 3 > pixel;
             pixel.SetElement(0, dir[0]);
             pixel.SetElement(1, dir[1]);
             pixel.SetElement(2, dir[2]);
             directionImage->SetPixel(index, pixel);
 
             // add direction to vector field (with spacing compensation)
             itk::Point<float> worldStart;
             worldStart[0] = worldCenter[0]-dir[0]/2*minSpacing;
             worldStart[1] = worldCenter[1]-dir[1]/2*minSpacing;
             worldStart[2] = worldCenter[2]-dir[2]/2*minSpacing;
             vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             itk::Point<float> worldEnd;
             worldEnd[0] = worldCenter[0]+dir[0]/2*minSpacing;
             worldEnd[1] = worldCenter[1]+dir[1]/2*minSpacing;
             worldEnd[2] = worldCenter[2]+dir[2]/2*minSpacing;
             id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             m_VtkCellArray->InsertNextCell(container);
         }
         dirIt.Set(numDir);
         ++dirIt;
     }
 
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
     m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
 }
 
 
 template< class PixelType >
 std::vector< vnl_vector_fixed< double, 3 > > TractsToVectorImageFilter< PixelType >::FastClustering(std::vector< vnl_vector_fixed< double, 3 > >& inDirs)
 {
     std::vector< vnl_vector_fixed< double, 3 > > outDirs;
     if (inDirs.empty())
         return outDirs;
     vnl_vector_fixed< double, 3 > oldMean, currentMean, workingMean;
 
     std::vector< vnl_vector_fixed< double, 3 > > normalizedDirs;
     std::vector< int > touched;
     for (int i=0; i<inDirs.size(); i++)
     {
         normalizedDirs.push_back(inDirs[i]);
         normalizedDirs.back().normalize();
     }
 
     // initialize
     float max = 0.0;
     touched.resize(inDirs.size(), 0);
     bool free = true;
     currentMean = inDirs[0];  // initialize first seed
     while (free)
     {
         oldMean.fill(0.0);
 
         // start mean-shift clustering
         float angle = 0.0;
         int counter = 0;
         while ((currentMean-oldMean).magnitude()>0.0001)
         {
             counter = 0;
             oldMean = currentMean;
             workingMean = oldMean;
             workingMean.normalize();
             currentMean.fill(0.0);
             for (int i=0; i<normalizedDirs.size(); i++)
             {
                 angle = dot_product(workingMean, normalizedDirs[i]);
                 if (angle>=m_AngularThreshold)
                 {
                     currentMean += inDirs[i];
                     touched[i] = 1;
                     counter++;
                 }
                 else if (-angle>=m_AngularThreshold)
                 {
                     currentMean -= inDirs[i];
                     touched[i] = 1;
                     counter++;
                 }
             }
         }
 
         // found stable mean
         if (counter>0)
         {
             currentMean /= counter;
             float mag = currentMean.magnitude();
 
             if (mag>0)
             {
                 if (mag>max)
                     max = mag;
 
                 outDirs.push_back(currentMean);
             }
         }
 
         // find next unused seed
         free = false;
         for (int i=0; i<touched.size(); i++)
             if (touched[i]==0)
             {
                 currentMean = inDirs[i];
                 free = true;
             }
     }
 
     if (m_NormalizeVectors)
         for (int i=0; i<outDirs.size(); i++)
             outDirs[i].normalize();
     else if (max>0)
         for (int i=0; i<outDirs.size(); i++)
             outDirs[i] /= max;
 
     if (inDirs.size()==outDirs.size())
         return outDirs;
     else
         return FastClustering(outDirs);
 }
 
 
 template< class PixelType >
 std::vector< vnl_vector_fixed< double, 3 > > TractsToVectorImageFilter< PixelType >::Clustering(std::vector< vnl_vector_fixed< double, 3 > >& inDirs)
 {
     std::vector< vnl_vector_fixed< double, 3 > > outDirs;
     if (inDirs.empty())
         return outDirs;
     vnl_vector_fixed< double, 3 > oldMean, currentMean, workingMean;
 
     std::vector< vnl_vector_fixed< double, 3 > > normalizedDirs;
     std::vector< int > touched;
     for (int i=0; i<inDirs.size(); i++)
     {
         normalizedDirs.push_back(inDirs[i]);
         normalizedDirs.back().normalize();
     }
 
     // initialize
     float max = 0.0;
     touched.resize(inDirs.size(), 0);
     for (int j=0; j<inDirs.size(); j++)
     {
         currentMean = inDirs[j];
         oldMean.fill(0.0);
 
         // start mean-shift clustering
         float angle = 0.0;
         int counter = 0;
         while ((currentMean-oldMean).magnitude()>0.0001)
         {
             counter = 0;
             oldMean = currentMean;
             workingMean = oldMean;
             workingMean.normalize();
             currentMean.fill(0.0);
             for (int i=0; i<normalizedDirs.size(); i++)
             {
                 angle = dot_product(workingMean, normalizedDirs[i]);
                 if (angle>=m_AngularThreshold)
                 {
                     currentMean += inDirs[i];
                     counter++;
                 }
                 else if (-angle>=m_AngularThreshold)
                 {
                     currentMean -= inDirs[i];
                     counter++;
                 }
             }
         }
 
         // found stable mean
         if (counter>0)
         {
             bool add = true;
             vnl_vector_fixed< double, 3 > normMean = currentMean;
             normMean.normalize();
             for (int i=0; i<outDirs.size(); i++)
             {
                 vnl_vector_fixed< double, 3 > dir = outDirs[i];
                 dir.normalize();
                 if ((normMean-dir).magnitude()<=0.0001)
                 {
                     add = false;
                     break;
                 }
             }
 
             currentMean /= counter;
             if (add)
             {
                 float mag = currentMean.magnitude();
                 if (mag>0)
                 {
                     if (mag>max)
                         max = mag;
 
                     outDirs.push_back(currentMean);
                 }
             }
         }
     }
 
     if (m_NormalizeVectors)
         for (int i=0; i<outDirs.size(); i++)
             outDirs[i].normalize();
     else if (max>0)
         for (int i=0; i<outDirs.size(); i++)
             outDirs[i] /= max;
 
     if (inDirs.size()==outDirs.size())
         return outDirs;
     else
         return FastClustering(outDirs);
 }
 
 
 template< class PixelType >
 TractsToVectorImageFilter< PixelType >::DirectionContainerType::Pointer TractsToVectorImageFilter< PixelType >::MeanShiftClustering(DirectionContainerType::Pointer dirCont)
 {
     DirectionContainerType::Pointer container = DirectionContainerType::New();
 
     float max = 0;
     for (DirectionContainerType::ConstIterator it = dirCont->Begin(); it!=dirCont->End(); ++it)
     {
         vnl_vector_fixed<double, 3> mean = ClusterStep(dirCont, it.Value());
 
         if (mean.is_zero())
             continue;
         bool addMean = true;
 
         for (DirectionContainerType::ConstIterator it2 = container->Begin(); it2!=container->End(); ++it2)
         {
             vnl_vector_fixed<double, 3> dir = it2.Value();
             float angle = fabs(dot_product(mean, dir)/(mean.magnitude()*dir.magnitude()));
             if (angle>=m_Epsilon)
             {
                 addMean = false;
                 break;
             }
         }
 
         if (addMean)
         {
             if (m_NormalizeVectors)
                 mean.normalize();
             else if (mean.magnitude()>max)
                 max = mean.magnitude();
             container->InsertElement(container->Size(), mean);
         }
     }
 
     // max normalize voxel directions
     if (max>0 && !m_NormalizeVectors)
         for (int i=0; i<container->Size(); i++)
             container->ElementAt(i) /= max;
 
     if (container->Size()<dirCont->Size())
         return MeanShiftClustering(container);
     else
         return container;
 }
 
 
 template< class PixelType >
 vnl_vector_fixed<double, 3> TractsToVectorImageFilter< PixelType >::ClusterStep(DirectionContainerType::Pointer dirCont, vnl_vector_fixed<double, 3> currentMean)
 {
     vnl_vector_fixed<double, 3> newMean; newMean.fill(0);
 
     for (DirectionContainerType::ConstIterator it = dirCont->Begin(); it!=dirCont->End(); ++it)
     {
         vnl_vector_fixed<double, 3> dir = it.Value();
         float angle = dot_product(currentMean, dir)/(currentMean.magnitude()*dir.magnitude());
         if (angle>=m_AngularThreshold)
             newMean += dir;
         else if (-angle>=m_AngularThreshold)
             newMean -= dir;
     }
 
     if (fabs(dot_product(currentMean, newMean)/(currentMean.magnitude()*newMean.magnitude()))>=m_Epsilon || newMean.is_zero())
         return newMean;
     else
         return ClusterStep(dirCont, newMean);
 }
 }
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
index e6dc0ce039..48edf72753 100755
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
@@ -1,1801 +1,1799 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #define _USE_MATH_DEFINES
 #include "mitkFiberBundleX.h"
 
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarFigureComposite.h>
 #include "mitkImagePixelReadAccessor.h"
 #include <mitkPixelTypeMultiplex.h>
 
 #include <vtkPointData.h>
 #include <vtkDataArray.h>
 #include <vtkUnsignedCharArray.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 #include <vtkIdFilter.h>
 #include <vtkClipPolyData.h>
 #include <vtkPlane.h>
 #include <vtkDoubleArray.h>
 #include <vtkKochanekSpline.h>
 #include <vtkParametricFunctionSource.h>
 #include <vtkParametricSpline.h>
 #include <vtkPolygon.h>
 #include <vtkCleanPolyData.h>
 #include <cmath>
-#ifndef Q_MOC_RUN
-#  include <boost/progress.hpp>
-#endif
+#include <boost/progress.hpp>
 
 const char* mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED = "Color_Orient";
 //const char* mitk::FiberBundleX::COLORCODING_FA_AS_OPACITY = "Color_Orient_FA_Opacity";
 const char* mitk::FiberBundleX::COLORCODING_FA_BASED = "FA_Values";
 const char* mitk::FiberBundleX::COLORCODING_CUSTOM = "custom";
 const char* mitk::FiberBundleX::FIBER_ID_ARRAY = "Fiber_IDs";
 
 using namespace std;
 
 mitk::FiberBundleX::FiberBundleX( vtkPolyData* fiberPolyData )
     : m_CurrentColorCoding(NULL)
     , m_NumFibers(0)
     , m_FiberSampling(0)
 {
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     if (fiberPolyData != NULL)
     {
         m_FiberPolyData = fiberPolyData;
         //m_FiberPolyData->DeepCopy(fiberPolyData);
         this->DoColorCodingOrientationBased();
     }
 
     this->UpdateFiberGeometry();
     this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
     this->GenerateFiberIds();
 }
 
 mitk::FiberBundleX::~FiberBundleX()
 {
 
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::GetDeepCopy()
 {
     mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(m_FiberPolyData);
     newFib->SetColorCoding(m_CurrentColorCoding);
     return newFib;
 }
 
 vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GeneratePolyDataByIds(std::vector<long> fiberIds)
 {
     MITK_DEBUG << "\n=====FINAL RESULT: fib_id ======\n";
     MITK_DEBUG << "Number of new Fibers: " << fiberIds.size();
     // iterate through the vectorcontainer hosting all desired fiber Ids
 
     vtkSmartPointer<vtkPolyData> newFiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> newLineSet = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> newPointSet = vtkSmartPointer<vtkPoints>::New();
 
     // if FA array available, initialize fa double array
     // if color orient array is available init color array
     vtkSmartPointer<vtkDoubleArray> faValueArray;
     vtkSmartPointer<vtkUnsignedCharArray> colorsT;
     //colors and alpha value for each single point, RGBA = 4 components
     unsigned char rgba[4] = {0,0,0,0};
     int componentSize = sizeof(rgba);
 
     if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_FA_BASED)){
         MITK_DEBUG << "FA VALUES AVAILABLE, init array for new fiberbundle";
         faValueArray = vtkSmartPointer<vtkDoubleArray>::New();
     }
 
     if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED)){
         MITK_DEBUG << "colorValues available, init array for new fiberbundle";
         colorsT = vtkUnsignedCharArray::New();
         colorsT->SetNumberOfComponents(componentSize);
         colorsT->SetName(COLORCODING_ORIENTATION_BASED);
     }
 
 
 
     std::vector<long>::iterator finIt = fiberIds.begin();
     while ( finIt != fiberIds.end() )
     {
         if (*finIt < 0 || *finIt>GetNumFibers()){
             MITK_INFO << "FiberID can not be negative or >NumFibers!!! check id Extraction!" << *finIt;
             break;
         }
 
         vtkSmartPointer<vtkCell> fiber = m_FiberIdDataSet->GetCell(*finIt);//->DeepCopy(fiber);
 
         vtkSmartPointer<vtkPoints> fibPoints = fiber->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
         newFiber->GetPointIds()->SetNumberOfIds( fibPoints->GetNumberOfPoints() );
 
         for(int i=0; i<fibPoints->GetNumberOfPoints(); i++)
         {
             //            MITK_DEBUG << "id: " << fiber->GetPointId(i);
             //            MITK_DEBUG << fibPoints->GetPoint(i)[0] << " | " << fibPoints->GetPoint(i)[1] << " | " << fibPoints->GetPoint(i)[2];
             newFiber->GetPointIds()->SetId(i, newPointSet->GetNumberOfPoints());
             newPointSet->InsertNextPoint(fibPoints->GetPoint(i)[0], fibPoints->GetPoint(i)[1], fibPoints->GetPoint(i)[2]);
 
 
             if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_FA_BASED)){
                 //                MITK_DEBUG << m_FiberIdDataSet->GetPointData()->GetArray(FA_VALUE_ARRAY)->GetTuple(fiber->GetPointId(i));
             }
 
             if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED)){
                 //                MITK_DEBUG << "ColorValue: " << m_FiberIdDataSet->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetTuple(fiber->GetPointId(i))[0];
             }
         }
 
         newLineSet->InsertNextCell(newFiber);
         ++finIt;
     }
 
     newFiberPolyData->SetPoints(newPointSet);
     newFiberPolyData->SetLines(newLineSet);
     MITK_DEBUG << "new fiberbundle polydata points: " << newFiberPolyData->GetNumberOfPoints();
     MITK_DEBUG << "new fiberbundle polydata lines: " << newFiberPolyData->GetNumberOfLines();
     MITK_DEBUG << "=====================\n";
 
     //    mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(newFiberPolyData);
     return newFiberPolyData;
 }
 
 // merge two fiber bundles
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::AddBundle(mitk::FiberBundleX* fib)
 {
     if (fib==NULL)
     {
         MITK_WARN << "trying to call AddBundle with NULL argument";
         return NULL;
     }
     MITK_INFO << "Adding fibers";
 
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
     // add current fiber bundle
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vNewLines->InsertNextCell(container);
     }
 
     // add new fiber bundle
     for (int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
     {
         vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vNewLines->InsertNextCell(container);
     }
 
     // initialize polydata
     vNewPolyData->SetPoints(vNewPoints);
     vNewPolyData->SetLines(vNewLines);
 
     // initialize fiber bundle
     mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
     return newFib;
 }
 
 // subtract two fiber bundles
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::SubtractBundle(mitk::FiberBundleX* fib)
 {
     MITK_INFO << "Subtracting fibers";
 
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
     // iterate over current fibers
     int numFibers = GetNumFibers();
     boost::progress_display disp(numFibers);
     for( int i=0; i<numFibers; i++ )
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (points==NULL || numPoints<=0)
             continue;
 
         int numFibers2 = fib->GetNumFibers();
         bool contained = false;
         for( int i2=0; i2<numFibers2; i2++ )
         {
             vtkCell* cell2 = fib->GetFiberPolyData()->GetCell(i2);
             int numPoints2 = cell2->GetNumberOfPoints();
             vtkPoints* points2 = cell2->GetPoints();
 
             if (points2==NULL || numPoints2<=0)
                 continue;
 
             // check endpoints
             itk::Point<float, 3> point_start = GetItkPoint(points->GetPoint(0));
             itk::Point<float, 3> point_end = GetItkPoint(points->GetPoint(numPoints-1));
             itk::Point<float, 3> point2_start = GetItkPoint(points2->GetPoint(0));
             itk::Point<float, 3> point2_end = GetItkPoint(points2->GetPoint(numPoints2-1));
 
             if (point_start.SquaredEuclideanDistanceTo(point2_start)<=mitk::eps && point_end.SquaredEuclideanDistanceTo(point2_end)<=mitk::eps ||
                     point_start.SquaredEuclideanDistanceTo(point2_end)<=mitk::eps && point_end.SquaredEuclideanDistanceTo(point2_start)<=mitk::eps)
             {
                 // further checking ???
                 if (numPoints2==numPoints)
                     contained = true;
             }
         }
 
         // add to result because fiber is not subtracted
         if (!contained)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for( int j=0; j<numPoints; j++)
             {
                 vtkIdType id = vNewPoints->InsertNextPoint(points->GetPoint(j));
                 container->GetPointIds()->InsertNextId(id);
             }
             vNewLines->InsertNextCell(container);
         }
     }
     if(vNewLines->GetNumberOfCells()==0)
         return NULL;
     // initialize polydata
     vNewPolyData->SetPoints(vNewPoints);
     vNewPolyData->SetLines(vNewLines);
 
     // initialize fiber bundle
     mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
     return newFib;
 }
 
 itk::Point<float, 3> mitk::FiberBundleX::GetItkPoint(double point[3])
 {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 /*
  * set polydata (additional flag to recompute fiber geometry, default = true)
  */
 void mitk::FiberBundleX::SetFiberPolyData(vtkSmartPointer<vtkPolyData> fiberPD, bool updateGeometry)
 {
     if (fiberPD == NULL)
         this->m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     else
     {
         m_FiberPolyData->DeepCopy(fiberPD);
         DoColorCodingOrientationBased();
     }
 
     m_NumFibers = m_FiberPolyData->GetNumberOfLines();
 
     if (updateGeometry)
         UpdateFiberGeometry();
     SetColorCoding(COLORCODING_ORIENTATION_BASED);
     GenerateFiberIds();
 }
 
 /*
  * return vtkPolyData
  */
 vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GetFiberPolyData()
 {
     return m_FiberPolyData;
 }
 
 void mitk::FiberBundleX::DoColorCodingOrientationBased()
 {
     //===== FOR WRITING A TEST ========================
     //  colorT size == tupelComponents * tupelElements
     //  compare color results
     //  to cover this code 100% also polydata needed, where colorarray already exists
     //  + one fiber with exactly 1 point
     //  + one fiber with 0 points
     //=================================================
 
 
     /*  make sure that processing colorcoding is only called when necessary */
     if ( m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED) &&
          m_FiberPolyData->GetNumberOfPoints() ==
          m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetNumberOfTuples() )
     {
         // fiberstructure is already colorcoded
         MITK_DEBUG << " NO NEED TO REGENERATE COLORCODING! " ;
         this->ResetFiberOpacity();
         this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
         return;
     }
 
     /* Finally, execute color calculation */
     vtkPoints* extrPoints = NULL;
     extrPoints = m_FiberPolyData->GetPoints();
     int numOfPoints = 0;
     if (extrPoints!=NULL)
         numOfPoints = extrPoints->GetNumberOfPoints();
 
     //colors and alpha value for each single point, RGBA = 4 components
     unsigned char rgba[4] = {0,0,0,0};
     //    int componentSize = sizeof(rgba);
     int componentSize = 4;
 
     vtkSmartPointer<vtkUnsignedCharArray> colorsT = vtkSmartPointer<vtkUnsignedCharArray>::New();
     colorsT->Allocate(numOfPoints * componentSize);
     colorsT->SetNumberOfComponents(componentSize);
     colorsT->SetName(COLORCODING_ORIENTATION_BASED);
 
 
 
     /* checkpoint: does polydata contain any fibers */
     int numOfFibers = m_FiberPolyData->GetNumberOfLines();
     if (numOfFibers < 1) {
         MITK_DEBUG << "\n ========= Number of Fibers is 0 and below ========= \n";
         return;
     }
 
 
     /* extract single fibers of fiberBundle */
     vtkCellArray* fiberList = m_FiberPolyData->GetLines();
     fiberList->InitTraversal();
     for (int fi=0; fi<numOfFibers; ++fi) {
 
         vtkIdType* idList; // contains the point id's of the line
         vtkIdType pointsPerFiber; // number of points for current line
         fiberList->GetNextCell(pointsPerFiber, idList);
 
         //    MITK_DEBUG << "Fib#: " << fi << " of " << numOfFibers << " pnts in fiber: " << pointsPerFiber ;
 
         /* single fiber checkpoints: is number of points valid */
         if (pointsPerFiber > 1)
         {
             /* operate on points of single fiber */
             for (int i=0; i <pointsPerFiber; ++i)
             {
                 /* process all points except starting and endpoint
          * for calculating color value take current point, previous point and next point */
                 if (i<pointsPerFiber-1 && i > 0)
                 {
                     /* The color value of the current point is influenced by the previous point and next point. */
                     vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
                     vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
                     vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
 
                     vnl_vector_fixed< double, 3 > diff1;
                     diff1 = currentPntvtk - nextPntvtk;
 
                     vnl_vector_fixed< double, 3 > diff2;
                     diff2 = currentPntvtk - prevPntvtk;
 
                     vnl_vector_fixed< double, 3 > diff;
                     diff = (diff1 - diff2) / 2.0;
                     diff.normalize();
 
                     rgba[0] = (unsigned char) (255.0 * std::fabs(diff[0]));
                     rgba[1] = (unsigned char) (255.0 * std::fabs(diff[1]));
                     rgba[2] = (unsigned char) (255.0 * std::fabs(diff[2]));
                     rgba[3] = (unsigned char) (255.0);
 
 
                 } else if (i==0) {
                     /* First point has no previous point, therefore only diff1 is taken */
 
                     vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
                     vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
 
                     vnl_vector_fixed< double, 3 > diff1;
                     diff1 = currentPntvtk - nextPntvtk;
                     diff1.normalize();
 
                     rgba[0] = (unsigned char) (255.0 * std::fabs(diff1[0]));
                     rgba[1] = (unsigned char) (255.0 * std::fabs(diff1[1]));
                     rgba[2] = (unsigned char) (255.0 * std::fabs(diff1[2]));
                     rgba[3] = (unsigned char) (255.0);
 
 
                 } else if (i==pointsPerFiber-1) {
                     /* Last point has no next point, therefore only diff2 is taken */
                     vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
                     vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
 
                     vnl_vector_fixed< double, 3 > diff2;
                     diff2 = currentPntvtk - prevPntvtk;
                     diff2.normalize();
 
                     rgba[0] = (unsigned char) (255.0 * std::fabs(diff2[0]));
                     rgba[1] = (unsigned char) (255.0 * std::fabs(diff2[1]));
                     rgba[2] = (unsigned char) (255.0 * std::fabs(diff2[2]));
                     rgba[3] = (unsigned char) (255.0);
 
                 }
 
                 colorsT->InsertTupleValue(idList[i], rgba);
 
             } //end for loop
 
         } else if (pointsPerFiber == 1) {
             /* a single point does not define a fiber (use vertex mechanisms instead */
             continue;
             //      colorsT->InsertTupleValue(0, rgba);
 
         } else {
             MITK_DEBUG << "Fiber with 0 points detected... please check your tractography algorithm!" ;
             continue;
 
         }
 
 
     }//end for loop
 
     m_FiberPolyData->GetPointData()->AddArray(colorsT);
 
     /*=========================
       - this is more relevant for renderer than for fiberbundleX datastructure
       - think about sourcing this to a explicit method which coordinates colorcoding */
     this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
     //  ===========================
 
     //mini test, shall be ported to MITK TESTINGS!
     if (colorsT->GetSize() != numOfPoints*componentSize)
         MITK_DEBUG << "ALLOCATION ERROR IN INITIATING COLOR ARRAY";
 
 
 }
 
 void mitk::FiberBundleX::DoColorCodingFaBased()
 {
     if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED) != 1 )
         return;
 
     this->SetColorCoding(COLORCODING_FA_BASED);
     MITK_DEBUG << "FBX: done CC FA based";
     this->GenerateFiberIds();
 }
 
 void mitk::FiberBundleX::DoUseFaFiberOpacity()
 {
     if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED) != 1 )
         return;
 
     if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED) != 1 )
         return;
 
     vtkDoubleArray* FAValArray = (vtkDoubleArray*) m_FiberPolyData->GetPointData()->GetArray(COLORCODING_FA_BASED);
     vtkUnsignedCharArray* ColorArray = dynamic_cast<vtkUnsignedCharArray*>  (m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED));
 
     for(long i=0; i<ColorArray->GetNumberOfTuples(); i++) {
         double faValue = FAValArray->GetValue(i);
         faValue = faValue * 255.0;
         ColorArray->SetComponent(i,3, (unsigned char) faValue );
     }
 
     this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
     MITK_DEBUG << "FBX: done CC OPACITY";
     this->GenerateFiberIds();
 }
 
 void mitk::FiberBundleX::ResetFiberOpacity() {
     vtkUnsignedCharArray* ColorArray = dynamic_cast<vtkUnsignedCharArray*>  (m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED));
     if (ColorArray==NULL)
         return;
     for(long i=0; i<ColorArray->GetNumberOfTuples(); i++)
         ColorArray->SetComponent(i,3, 255.0 );
 }
 
 void mitk::FiberBundleX::SetFAMap(mitk::Image::Pointer FAimage)
 {
    mitkPixelTypeMultiplex1( SetFAMap, FAimage->GetPixelType(), FAimage );
 }
 
 template <typename TPixel>
 void mitk::FiberBundleX::SetFAMap(const mitk::PixelType pixelType, mitk::Image::Pointer FAimage)
 {
   MITK_DEBUG << "SetFAMap";
   vtkSmartPointer<vtkDoubleArray> faValues = vtkSmartPointer<vtkDoubleArray>::New();
   faValues->SetName(COLORCODING_FA_BASED);
   faValues->Allocate(m_FiberPolyData->GetNumberOfPoints());
   faValues->SetNumberOfValues(m_FiberPolyData->GetNumberOfPoints());
 
   mitk::ImagePixelReadAccessor<TPixel,3> readFAimage (FAimage, FAimage->GetVolumeData(0));
 
   vtkPoints* pointSet = m_FiberPolyData->GetPoints();
   for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
   {
       Point3D px;
       px[0] = pointSet->GetPoint(i)[0];
       px[1] = pointSet->GetPoint(i)[1];
       px[2] = pointSet->GetPoint(i)[2];
       double faPixelValue = 1-readFAimage.GetPixelByWorldCoordinates(px);
       faValues->InsertValue(i, faPixelValue);
   }
 
   m_FiberPolyData->GetPointData()->AddArray(faValues);
   this->GenerateFiberIds();
 
   if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED))
       MITK_DEBUG << "FA VALUE ARRAY SET";
 
 }
 
 
 void mitk::FiberBundleX::GenerateFiberIds()
 {
     if (m_FiberPolyData == NULL)
         return;
 
     vtkSmartPointer<vtkIdFilter> idFiberFilter = vtkSmartPointer<vtkIdFilter>::New();
     idFiberFilter->SetInput(m_FiberPolyData);
     idFiberFilter->CellIdsOn();
     //  idFiberFilter->PointIdsOn(); // point id's are not needed
     idFiberFilter->SetIdsArrayName(FIBER_ID_ARRAY);
     idFiberFilter->FieldDataOn();
     idFiberFilter->Update();
 
     m_FiberIdDataSet = idFiberFilter->GetOutput();
 
     MITK_DEBUG << "Generating Fiber Ids...[done] | " << m_FiberIdDataSet->GetNumberOfCells();
 
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint)
 {
     vtkSmartPointer<vtkPolyData> polyData = m_FiberPolyData;
     if (anyPoint)
     {
         float minSpacing = 1;
         if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
             minSpacing = mask->GetSpacing()[0];
         else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
             minSpacing = mask->GetSpacing()[1];
         else
             minSpacing = mask->GetSpacing()[2];
 
         mitk::FiberBundleX::Pointer fibCopy = this->GetDeepCopy();
         fibCopy->ResampleFibers(minSpacing/10);
         polyData = fibCopy->GetFiberPolyData();
     }
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Extracting fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
 
         vtkCell* cell = polyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkCell* cellOriginal = m_FiberPolyData->GetCell(i);
         int numPointsOriginal = cellOriginal->GetNumberOfPoints();
         vtkPoints* pointsOriginal = cellOriginal->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
         if (numPoints>1 && numPointsOriginal)
         {
             if (anyPoint)
             {
                 for (int j=0; j<numPoints; j++)
                 {
                     double* p = points->GetPoint(j);
 
                     itk::Point<float, 3> itkP;
                     itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                     itk::Index<3> idx;
                     mask->TransformPhysicalPointToIndex(itkP, idx);
 
                     if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) )
                     {
                         for (int k=0; k<numPointsOriginal; k++)
                         {
                             double* p = pointsOriginal->GetPoint(k);
                             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                             container->GetPointIds()->InsertNextId(id);
                         }
                         break;
                     }
                 }
             }
             else
             {
                 double* start = pointsOriginal->GetPoint(0);
                 itk::Point<float, 3> itkStart;
                 itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
                 itk::Index<3> idxStart;
                 mask->TransformPhysicalPointToIndex(itkStart, idxStart);
 
                 double* end = pointsOriginal->GetPoint(numPointsOriginal-1);
                 itk::Point<float, 3> itkEnd;
                 itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
                 itk::Index<3> idxEnd;
                 mask->TransformPhysicalPointToIndex(itkEnd, idxEnd);
 
                 if ( mask->GetPixel(idxStart)>0 && mask->GetPixel(idxEnd)>0 && mask->GetLargestPossibleRegion().IsInside(idxStart) && mask->GetLargestPossibleRegion().IsInside(idxEnd) )
                 {
                     for (int j=0; j<numPointsOriginal; j++)
                     {
                         double* p = pointsOriginal->GetPoint(j);
                         vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                         container->GetPointIds()->InsertNextId(id);
                     }
                 }
             }
         }
 
         vtkNewCells->InsertNextCell(container);
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return NULL;
 
     vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
     newPolyData->SetPoints(vtkNewPoints);
     newPolyData->SetLines(vtkNewCells);
     return mitk::FiberBundleX::New(newPolyData);
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::RemoveFibersOutside(ItkUcharImgType* mask, bool invert)
 {
     float minSpacing = 1;
     if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
         minSpacing = mask->GetSpacing()[0];
     else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
         minSpacing = mask->GetSpacing()[1];
     else
         minSpacing = mask->GetSpacing()[2];
 
     mitk::FiberBundleX::Pointer fibCopy = this->GetDeepCopy();
     fibCopy->ResampleFibers(minSpacing/10);
     vtkSmartPointer<vtkPolyData> polyData =fibCopy->GetFiberPolyData();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Cutting fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
 
         vtkCell* cell = polyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         if (numPoints>1)
         {
             int newNumPoints = 0;
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
 
                 itk::Point<float, 3> itkP;
                 itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                 itk::Index<3> idx;
                 mask->TransformPhysicalPointToIndex(itkP, idx);
 
                 if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) && !invert )
                 {
                     vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                     container->GetPointIds()->InsertNextId(id);
                     newNumPoints++;
                 }
                 else if ( (mask->GetPixel(idx)<=0 || !mask->GetLargestPossibleRegion().IsInside(idx)) && invert )
                 {
                     vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                     container->GetPointIds()->InsertNextId(id);
                     newNumPoints++;
                 }
                 else if (newNumPoints>0)
                 {
                     vtkNewCells->InsertNextCell(container);
 
                     newNumPoints = 0;
                     container = vtkSmartPointer<vtkPolyLine>::New();
                 }
             }
 
             if (newNumPoints>0)
                 vtkNewCells->InsertNextCell(container);
         }
 
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return NULL;
 
     vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
     newPolyData->SetPoints(vtkNewPoints);
     newPolyData->SetLines(vtkNewCells);
     return mitk::FiberBundleX::New(newPolyData);
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(mitk::PlanarFigure* pf)
 {
     if (pf==NULL)
         return NULL;
 
     std::vector<long> tmp = ExtractFiberIdSubset(pf);
 
     if (tmp.size()<=0)
         return mitk::FiberBundleX::New();
     vtkSmartPointer<vtkPolyData> pTmp = GeneratePolyDataByIds(tmp);
     return mitk::FiberBundleX::New(pTmp);
 }
 
 std::vector<long> mitk::FiberBundleX::ExtractFiberIdSubset(mitk::PlanarFigure* pf)
 {
     MITK_DEBUG << "Extracting fibers!";
     // vector which is returned, contains all extracted FiberIds
     std::vector<long> FibersInROI;
 
     if (pf==NULL)
         return FibersInROI;
 
     /* Handle type of planarfigure */
     // if incoming pf is a pfc
     mitk::PlanarFigureComposite::Pointer pfcomp= dynamic_cast<mitk::PlanarFigureComposite*>(pf);
     if (!pfcomp.IsNull()) {
         // process requested boolean operation of PFC
         switch (pfcomp->getOperationType()) {
         case 0:
         {
             MITK_DEBUG << "AND PROCESSING";
             //AND
             //temporarly store results of the child in this vector, we need that to accumulate the
             std::vector<long> childResults = this->ExtractFiberIdSubset(pfcomp->getChildAt(0));
             MITK_DEBUG << "first roi got fibers in ROI: " << childResults.size();
             MITK_DEBUG << "sorting...";
             std::sort(childResults.begin(), childResults.end());
             MITK_DEBUG << "sorting done";
             std::vector<long> AND_Assamblage(childResults.size());
             //std::vector<unsigned long> AND_Assamblage;
             fill(AND_Assamblage.begin(), AND_Assamblage.end(), -1);
             //AND_Assamblage.reserve(childResults.size()); //max size AND can reach anyway
 
             std::vector<long>::iterator it;
             for (int i=1; i<pfcomp->getNumberOfChildren(); ++i)
             {
                 std::vector<long> tmpChild = this->ExtractFiberIdSubset(pfcomp->getChildAt(i));
                 MITK_DEBUG << "ROI " << i << " has fibers in ROI: " << tmpChild.size();
                 sort(tmpChild.begin(), tmpChild.end());
 
                 it = std::set_intersection(childResults.begin(), childResults.end(),
                                            tmpChild.begin(), tmpChild.end(),
                                            AND_Assamblage.begin() );
             }
 
             MITK_DEBUG << "resize Vector";
             long i=0;
             while (i < AND_Assamblage.size() && AND_Assamblage[i] != -1){ //-1 represents a placeholder in the array
                 ++i;
             }
             AND_Assamblage.resize(i);
 
             MITK_DEBUG << "returning AND vector, size: " << AND_Assamblage.size();
             return AND_Assamblage;
             //            break;
 
         }
         case 1:
         {
             //OR
             std::vector<long> OR_Assamblage = this->ExtractFiberIdSubset(pfcomp->getChildAt(0));
             std::vector<long>::iterator it;
             MITK_DEBUG << OR_Assamblage.size();
 
             for (int i=1; i<pfcomp->getNumberOfChildren(); ++i) {
                 it = OR_Assamblage.end();
                 std::vector<long> tmpChild = this->ExtractFiberIdSubset(pfcomp->getChildAt(i));
                 OR_Assamblage.insert(it, tmpChild.begin(), tmpChild.end());
                 MITK_DEBUG << "ROI " << i << " has fibers in ROI: " << tmpChild.size() << " OR Assamblage: " << OR_Assamblage.size();
             }
 
             sort(OR_Assamblage.begin(), OR_Assamblage.end());
             it = unique(OR_Assamblage.begin(), OR_Assamblage.end());
             OR_Assamblage.resize( it - OR_Assamblage.begin() );
             MITK_DEBUG << "returning OR vector, size: " << OR_Assamblage.size();
 
             return OR_Assamblage;
         }
         case 2:
         {
             //NOT
             //get IDs of all fibers
             std::vector<long> childResults;
             childResults.reserve(this->GetNumFibers());
             vtkSmartPointer<vtkDataArray> idSet = m_FiberIdDataSet->GetCellData()->GetArray(FIBER_ID_ARRAY);
             MITK_DEBUG << "m_NumOfFib: " << this->GetNumFibers() << " cellIdNum: " << idSet->GetNumberOfTuples();
             for(long i=0; i<this->GetNumFibers(); i++)
             {
                 MITK_DEBUG << "i: " << i << " idset: " << idSet->GetTuple(i)[0];
                 childResults.push_back(idSet->GetTuple(i)[0]);
             }
 
             std::sort(childResults.begin(), childResults.end());
             std::vector<long> NOT_Assamblage(childResults.size());
             //fill it with -1, otherwise 0 will be stored and 0 can also be an ID of fiber!
             fill(NOT_Assamblage.begin(), NOT_Assamblage.end(), -1);
             std::vector<long>::iterator it;
 
             for (long i=0; i<pfcomp->getNumberOfChildren(); ++i)
             {
                 std::vector<long> tmpChild = ExtractFiberIdSubset(pfcomp->getChildAt(i));
                 sort(tmpChild.begin(), tmpChild.end());
 
                 it = std::set_difference(childResults.begin(), childResults.end(),
                                          tmpChild.begin(), tmpChild.end(),
                                          NOT_Assamblage.begin() );
 
             }
 
             MITK_DEBUG << "resize Vector";
             long i=0;
             while (NOT_Assamblage[i] != -1){ //-1 represents a placeholder in the array
                 ++i;
             }
             NOT_Assamblage.resize(i);
 
             return NOT_Assamblage;
         }
         default:
             MITK_DEBUG << "we have an UNDEFINED composition... ERROR" ;
             break;
 
         }
     }
     else
     {
         mitk::Geometry2D::ConstPointer pfgeometry = pf->GetGeometry2D();
         const mitk::PlaneGeometry* planeGeometry = dynamic_cast<const mitk::PlaneGeometry*> (pfgeometry.GetPointer());
         Vector3D planeNormal = planeGeometry->GetNormal();
         planeNormal.Normalize();
         Point3D planeOrigin = planeGeometry->GetOrigin();
 
         MITK_DEBUG << "planeOrigin: " << planeOrigin[0] << " | " << planeOrigin[1] << " | " << planeOrigin[2] << endl;
         MITK_DEBUG << "planeNormal: " << planeNormal[0] << " | " << planeNormal[1] << " | " << planeNormal[2] << endl;
 
         std::vector<int> PointsOnPlane; // contains all pointIds which are crossing the cutting plane
         std::vector<int> PointsInROI; // based on PointsOnPlane, all ROI relevant point IDs are stored here
 
         /* Define cutting plane by ROI (PlanarFigure) */
         vtkSmartPointer<vtkPlane> plane = vtkSmartPointer<vtkPlane>::New();
         plane->SetOrigin(planeOrigin[0],planeOrigin[1],planeOrigin[2]);
         plane->SetNormal(planeNormal[0],planeNormal[1],planeNormal[2]);
 
         /* get all points/fibers cutting the plane */
         MITK_DEBUG << "start clipping";
         vtkSmartPointer<vtkClipPolyData> clipper = vtkSmartPointer<vtkClipPolyData>::New();
         clipper->SetInput(m_FiberIdDataSet);
         clipper->SetClipFunction(plane);
         clipper->GenerateClipScalarsOn();
         clipper->GenerateClippedOutputOn();
         vtkSmartPointer<vtkPolyData> clipperout = clipper->GetClippedOutput();
         MITK_DEBUG << "end clipping";
 
         MITK_DEBUG << "init and update clipperoutput";
         clipperout->GetPointData()->Initialize();
         clipperout->Update();
         MITK_DEBUG << "init and update clipperoutput completed";
 
         MITK_DEBUG << "STEP 1: find all points which have distance 0 to the given plane";
         /*======STEP 1======
       * extract all points, which are crossing the plane */
         // Scalar values describe the distance between each remaining point to the given plane. Values sorted by point index
         vtkSmartPointer<vtkDataArray> distanceList = clipperout->GetPointData()->GetScalars();
         vtkIdType sizeOfList =  distanceList->GetNumberOfTuples();
         PointsOnPlane.reserve(sizeOfList); /* use reserve for high-performant push_back, no hidden copy procedures are processed then!
                                          * size of list can be optimized by reducing allocation, but be aware of iterator and vector size*/
 
         for (int i=0; i<sizeOfList; ++i) {
             double *distance = distanceList->GetTuple(i);
 
             // check if point is on plane.
             // 0.01 due to some approximation errors when calculating distance
             if (distance[0] >= -0.01 && distance[0] <= 0.01)
                 PointsOnPlane.push_back(i);
         }
 
 
         MITK_DEBUG << "Num Of points on plane: " <<  PointsOnPlane.size();
 
         MITK_DEBUG << "Step 2: extract Interesting points with respect to given extraction planarFigure";
 
         PointsInROI.reserve(PointsOnPlane.size());
         /*=======STEP 2=====
      * extract ROI relevant pointIds */
 
         mitk::PlanarCircle::Pointer circleName = mitk::PlanarCircle::New();
         mitk::PlanarPolygon::Pointer polyName = mitk::PlanarPolygon::New();
         if ( pf->GetNameOfClass() == circleName->GetNameOfClass() )
         {
             //calculate circle radius
             mitk::Point3D V1w = pf->GetWorldControlPoint(0); //centerPoint
             mitk::Point3D V2w  = pf->GetWorldControlPoint(1); //radiusPoint
 
             double distPF = V1w.EuclideanDistanceTo(V2w);
 
             for (int i=0; i<PointsOnPlane.size(); i++)
             {
                 //distance between circle radius and given point
                 double XdistPnt =  sqrt((double) (clipperout->GetPoint(PointsOnPlane[i])[0] - V1w[0]) * (clipperout->GetPoint(PointsOnPlane[i])[0] - V1w[0]) +
                                         (clipperout->GetPoint(PointsOnPlane[i])[1] - V1w[1]) * (clipperout->GetPoint(PointsOnPlane[i])[1] - V1w[1]) +
                                         (clipperout->GetPoint(PointsOnPlane[i])[2] - V1w[2]) * (clipperout->GetPoint(PointsOnPlane[i])[2] - V1w[2])) ;
 
                 if( XdistPnt <= distPF)
                     PointsInROI.push_back(PointsOnPlane[i]);
             }
         }
         else if ( pf->GetNameOfClass() == polyName->GetNameOfClass() )
         {
             //create vtkPolygon using controlpoints from planarFigure polygon
             vtkSmartPointer<vtkPolygon> polygonVtk = vtkSmartPointer<vtkPolygon>::New();
 
             //get the control points from pf and insert them to vtkPolygon
             unsigned int nrCtrlPnts = pf->GetNumberOfControlPoints();
 
             for (int i=0; i<nrCtrlPnts; ++i)
             {
                 polygonVtk->GetPoints()->InsertNextPoint((double)pf->GetWorldControlPoint(i)[0], (double)pf->GetWorldControlPoint(i)[1], (double)pf->GetWorldControlPoint(i)[2] );
             }
 
             //prepare everything for using pointInPolygon function
             double n[3];
             polygonVtk->ComputeNormal(polygonVtk->GetPoints()->GetNumberOfPoints(),
                                       static_cast<double*>(polygonVtk->GetPoints()->GetData()->GetVoidPointer(0)), n);
 
             double bounds[6];
             polygonVtk->GetPoints()->GetBounds(bounds);
 
             for (int i=0; i<PointsOnPlane.size(); i++)
             {
                 double checkIn[3] = {clipperout->GetPoint(PointsOnPlane[i])[0], clipperout->GetPoint(PointsOnPlane[i])[1], clipperout->GetPoint(PointsOnPlane[i])[2]};
                 int isInPolygon = polygonVtk->PointInPolygon(checkIn, polygonVtk->GetPoints()->GetNumberOfPoints()
                                                              , static_cast<double*>(polygonVtk->GetPoints()->GetData()->GetVoidPointer(0)), bounds, n);
                 if( isInPolygon )
                     PointsInROI.push_back(PointsOnPlane[i]);
             }
         }
 
         MITK_DEBUG << "Step3: Identify fibers";
         // we need to access the fiberId Array, so make sure that this array is available
         if (!clipperout->GetCellData()->HasArray(FIBER_ID_ARRAY))
         {
             MITK_DEBUG << "ERROR: FiberID array does not exist, no correlation between points and fiberIds possible! Make sure calling GenerateFiberIds()";
             return FibersInROI; // FibersInRoi is empty then
         }
         if (PointsInROI.size()<=0)
             return FibersInROI;
 
         // prepare a structure where each point id is represented as an indexId.
         // vector looks like: | pntId | fiberIdx |
         std::vector< long > pointindexFiberMap;
 
         // walk through the whole subline section and create an vector sorted by point index
         vtkCellArray *clipperlines = clipperout->GetLines();
         clipperlines->InitTraversal();
         long numOfLineCells = clipperlines->GetNumberOfCells();
         long numofClippedPoints = clipperout->GetNumberOfPoints();
         pointindexFiberMap.resize(numofClippedPoints);
 
 
         //prepare resulting vector
         FibersInROI.reserve(PointsInROI.size());
 
         MITK_DEBUG << "\n===== Pointindex based structure initialized ======\n";
 
         // go through resulting "sub"lines which are stored as cells, "i" corresponds to current line id.
         for (int i=0, ic=0 ; i<numOfLineCells; i++, ic+=3)
         { //ic is the index counter for the cells hosting the desired information, eg. 2 | 45 | 46. each cell consits of 3 items.
 
             vtkIdType npts;
             vtkIdType *pts;
             clipperlines->GetCell(ic, npts, pts);
 
             // go through point ids in hosting subline, "j" corresponds to current pointindex in current line i. eg. idx[0]=45; idx[1]=46
             for (long j=0; j<npts; j++)
             {
                 // MITK_DEBUG << "writing fiber id: " << clipperout->GetCellData()->GetArray(FIBER_ID_ARRAY)->GetTuple(i)[0] << " to pointId: " << pts[j];
                 pointindexFiberMap[ pts[j] ] = clipperout->GetCellData()->GetArray(FIBER_ID_ARRAY)->GetTuple(i)[0];
                 // MITK_DEBUG << "in array: " << pointindexFiberMap[ pts[j] ];
             }
 
         }
 
         MITK_DEBUG << "\n===== Pointindex based structure finalized ======\n";
 
         // get all Points in ROI with according fiberID
         for (long k = 0; k < PointsInROI.size(); k++)
         {
             //MITK_DEBUG << "point " << PointsInROI[k] << " belongs to fiber " << pointindexFiberMap[ PointsInROI[k] ];
             if (pointindexFiberMap[ PointsInROI[k] ]<=GetNumFibers() && pointindexFiberMap[ PointsInROI[k] ]>=0)
                 FibersInROI.push_back(pointindexFiberMap[ PointsInROI[k] ]);
             else
                 MITK_INFO << "ERROR in ExtractFiberIdSubset; impossible fiber id detected";
         }
 
         m_PointsRoi = PointsInROI;
 
     }
 
     //  detecting fiberId duplicates
     MITK_DEBUG << "check for duplicates";
 
     sort(FibersInROI.begin(), FibersInROI.end());
     bool hasDuplicats = false;
     for(long i=0; i<FibersInROI.size()-1; ++i)
     {
         if(FibersInROI[i] == FibersInROI[i+1])
             hasDuplicats = true;
     }
 
     if(hasDuplicats)
     {
         std::vector<long>::iterator it;
         it = unique (FibersInROI.begin(), FibersInROI.end());
         FibersInROI.resize( it - FibersInROI.begin() );
     }
 
     return FibersInROI;
 }
 
 void mitk::FiberBundleX::UpdateFiberGeometry()
 {
     vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
     cleaner->SetInput(m_FiberPolyData);
     cleaner->PointMergingOff();
     cleaner->Update();
     m_FiberPolyData = cleaner->GetOutput();
 
     m_FiberLengths.clear();
     m_MeanFiberLength = 0;
     m_MedianFiberLength = 0;
     m_LengthStDev = 0;
     m_NumFibers = m_FiberPolyData->GetNumberOfCells();
 
     if (m_NumFibers<=0) // no fibers present; apply default geometry
     {
         m_MinFiberLength = 0;
         m_MaxFiberLength = 0;
         mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
         geometry->SetImageGeometry(true);
         float b[] = {0, 1, 0, 1, 0, 1};
         geometry->SetFloatBounds(b);
         SetGeometry(geometry);
         return;
     }
     float min = itk::NumericTraits<float>::NonpositiveMin();
     float max = itk::NumericTraits<float>::max();
     float b[] = {max, min, max, min, max, min};
 
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int p = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
         float length = 0;
         for (int j=0; j<p; j++)
         {
             // calculate bounding box
             double p1[3];
             points->GetPoint(j, p1);
 
             if (p1[0]<b[0])
                 b[0]=p1[0];
             if (p1[0]>b[1])
                 b[1]=p1[0];
 
             if (p1[1]<b[2])
                 b[2]=p1[1];
             if (p1[1]>b[3])
                 b[3]=p1[1];
 
             if (p1[2]<b[4])
                 b[4]=p1[2];
             if (p1[2]>b[5])
                 b[5]=p1[2];
 
             // calculate statistics
             if (j<p-1)
             {
                 double p2[3];
                 points->GetPoint(j+1, p2);
 
                 float dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2]));
                 length += dist;
             }
         }
         m_FiberLengths.push_back(length);
         m_MeanFiberLength += length;
         if (i==0)
         {
             m_MinFiberLength = length;
             m_MaxFiberLength = length;
         }
         else
         {
             if (length<m_MinFiberLength)
                 m_MinFiberLength = length;
             if (length>m_MaxFiberLength)
                 m_MaxFiberLength = length;
         }
     }
     m_MeanFiberLength /= m_NumFibers;
 
     std::vector< float > sortedLengths = m_FiberLengths;
     std::sort(sortedLengths.begin(), sortedLengths.end());
     for (int i=0; i<m_NumFibers; i++)
         m_LengthStDev += (m_MeanFiberLength-sortedLengths.at(i))*(m_MeanFiberLength-sortedLengths.at(i));
     if (m_NumFibers>1)
         m_LengthStDev /= (m_NumFibers-1);
     else
         m_LengthStDev = 0;
     m_LengthStDev = std::sqrt(m_LengthStDev);
     m_MedianFiberLength = sortedLengths.at(m_NumFibers/2);
 
     // provide some border margin
     for(int i=0; i<=4; i+=2)
         b[i] -=10;
     for(int i=1; i<=5; i+=2)
         b[i] +=10;
 
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
     geometry->SetFloatBounds(b);
     this->SetGeometry(geometry);
 }
 
 std::vector<std::string> mitk::FiberBundleX::GetAvailableColorCodings()
 {
     std::vector<std::string> availableColorCodings;
     int numColors = m_FiberPolyData->GetPointData()->GetNumberOfArrays();
     for(int i=0; i<numColors; i++)
     {
         availableColorCodings.push_back(m_FiberPolyData->GetPointData()->GetArrayName(i));
     }
 
     //this controlstructure shall be implemented by the calling method
     if (availableColorCodings.empty())
         MITK_DEBUG << "no colorcodings available in fiberbundleX";
 
     return availableColorCodings;
 }
 
 
 char* mitk::FiberBundleX::GetCurrentColorCoding()
 {
     return m_CurrentColorCoding;
 }
 
 void mitk::FiberBundleX::SetColorCoding(const char* requestedColorCoding)
 {
 
     if (requestedColorCoding==NULL)
         return;
     MITK_DEBUG << "SetColorCoding:" << requestedColorCoding;
 
     if( strcmp (COLORCODING_ORIENTATION_BASED,requestedColorCoding) == 0 )    {
         this->m_CurrentColorCoding = (char*) COLORCODING_ORIENTATION_BASED;
 
     } else if( strcmp (COLORCODING_FA_BASED,requestedColorCoding) == 0 ) {
         this->m_CurrentColorCoding = (char*) COLORCODING_FA_BASED;
 
     } else if( strcmp (COLORCODING_CUSTOM,requestedColorCoding) == 0 ) {
         this->m_CurrentColorCoding = (char*) COLORCODING_CUSTOM;
 
     } else {
         MITK_DEBUG << "FIBERBUNDLE X: UNKNOWN COLORCODING in FIBERBUNDLEX Datastructure";
         this->m_CurrentColorCoding = (char*) COLORCODING_CUSTOM; //will cause blank colorcoding of fibers
     }
 }
 
 void mitk::FiberBundleX::RotateAroundAxis(double x, double y, double z)
 {
     MITK_INFO << "Rotating fibers";
     x = x*M_PI/180;
     y = y*M_PI/180;
     z = z*M_PI/180;
 
     vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
     rotX[1][1] = cos(x);
     rotX[2][2] = rotX[1][1];
     rotX[1][2] = -sin(x);
     rotX[2][1] = -rotX[1][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
     rotY[0][0] = cos(y);
     rotY[2][2] = rotY[0][0];
     rotY[0][2] = sin(y);
     rotY[2][0] = -rotY[0][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
     rotZ[0][0] = cos(z);
     rotZ[1][1] = rotZ[0][0];
     rotZ[0][1] = -sin(z);
     rotZ[1][0] = -rotZ[0][1];
 
     mitk::Geometry3D::Pointer geom = this->GetGeometry();
     mitk::Point3D center = geom->GetCenter();
 
     boost::progress_display disp(m_NumFibers);
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             vnl_vector_fixed< double, 3 > dir;
             dir[0] = p[0]-center[0];
             dir[1] = p[1]-center[1];
             dir[2] = p[2]-center[2];
             dir = rotZ*rotY*rotX*dir;
             dir[0] += center[0];
             dir[1] += center[1];
             dir[2] += center[2];
             vtkIdType id = vtkNewPoints->InsertNextPoint(dir.data_block());
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     UpdateColorCoding();
     UpdateFiberGeometry();
 }
 
 void mitk::FiberBundleX::ScaleFibers(double x, double y, double z)
 {
     MITK_INFO << "Scaling fibers";
     boost::progress_display disp(m_NumFibers);
 
     mitk::Geometry3D* geom = this->GetGeometry();
     mitk::Point3D c = geom->GetCenter();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             p[0] -= c[0]; p[1] -= c[1]; p[2] -= c[2];
             p[0] *= x;
             p[1] *= y;
             p[2] *= z;
             p[0] += c[0]; p[1] += c[1]; p[2] += c[2];
             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     UpdateColorCoding();
     UpdateFiberGeometry();
 }
 
 void mitk::FiberBundleX::TranslateFibers(double x, double y, double z)
 {
     MITK_INFO << "Translating fibers";
     boost::progress_display disp(m_NumFibers);
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             p[0] += x;
             p[1] += y;
             p[2] += z;
             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     UpdateColorCoding();
     UpdateFiberGeometry();
 }
 
 void mitk::FiberBundleX::MirrorFibers(unsigned int axis)
 {
     if (axis>2)
         return;
 
     MITK_INFO << "Mirroring fibers";
     boost::progress_display disp(m_NumFibers);
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             p[axis] = -p[axis];
             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     UpdateColorCoding();
     UpdateFiberGeometry();
 }
 
 bool mitk::FiberBundleX::ApplyCurvatureThreshold(float minRadius, bool deleteFibers)
 {
     if (minRadius<0)
         return true;
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Applying curvature threshold";
     boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         // calculate curvatures
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints-2; j++)
         {
             double p1[3];
             points->GetPoint(j, p1);
             double p2[3];
             points->GetPoint(j+1, p2);
             double p3[3];
             points->GetPoint(j+2, p3);
 
             vnl_vector_fixed< float, 3 > v1, v2, v3;
 
             v1[0] = p2[0]-p1[0];
             v1[1] = p2[1]-p1[1];
             v1[2] = p2[2]-p1[2];
 
             v2[0] = p3[0]-p2[0];
             v2[1] = p3[1]-p2[1];
             v2[2] = p3[2]-p2[2];
 
             v3[0] = p1[0]-p3[0];
             v3[1] = p1[1]-p3[1];
             v3[2] = p1[2]-p3[2];
 
             float a = v1.magnitude();
             float b = v2.magnitude();
             float c = v3.magnitude();
             float r = a*b*c/std::sqrt((a+b+c)*(a+b-c)*(b+c-a)*(a-b+c)); // radius of triangle via Heron's formula (area of triangle)
 
             vtkIdType id = vtkNewPoints->InsertNextPoint(p1);
             container->GetPointIds()->InsertNextId(id);
 
             if (deleteFibers && r<minRadius)
                 break;
 
             if (r<minRadius)
             {
                 j += 2;
                 vtkNewCells->InsertNextCell(container);
                 container = vtkSmartPointer<vtkPolyLine>::New();
             }
             else if (j==numPoints-3)
             {
                 id = vtkNewPoints->InsertNextPoint(p2);
                 container->GetPointIds()->InsertNextId(id);
                 id = vtkNewPoints->InsertNextPoint(p3);
                 container->GetPointIds()->InsertNextId(id);
                 vtkNewCells->InsertNextCell(container);
             }
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return false;
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
 
     UpdateColorCoding();
     UpdateFiberGeometry();
     return true;
 }
 
 bool mitk::FiberBundleX::RemoveShortFibers(float lengthInMM)
 {
     MITK_INFO << "Removing short fibers";
     if (lengthInMM<=0 || lengthInMM<m_MinFiberLength)
     {
         MITK_INFO << "No fibers shorter than " << lengthInMM << " mm found!";
         return true;
     }
 
     if (lengthInMM>m_MaxFiberLength)    // can't remove all fibers
     {
         MITK_WARN << "Process aborted. No fibers would be left!";
         return false;
     }
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
     float min = m_MaxFiberLength;
 
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (m_FiberLengths.at(i)>=lengthInMM)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
                 vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
             }
             vtkNewCells->InsertNextCell(container);
             if (m_FiberLengths.at(i)<min)
                 min = m_FiberLengths.at(i);
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return false;
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
 
     UpdateColorCoding();
     UpdateFiberGeometry();
     return true;
 }
 
 bool mitk::FiberBundleX::RemoveLongFibers(float lengthInMM)
 {
     if (lengthInMM<=0 || lengthInMM>m_MaxFiberLength)
         return true;
 
     if (lengthInMM<m_MinFiberLength)    // can't remove all fibers
         return false;
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Removing long fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (m_FiberLengths.at(i)<=lengthInMM)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
                 vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
             }
             vtkNewCells->InsertNextCell(container);
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return false;
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     UpdateColorCoding();
     UpdateFiberGeometry();
     return true;
 }
 
 void mitk::FiberBundleX::DoFiberSmoothing(float pointDistance, double tension, double continuity, double bias )
 {
     if (pointDistance<=0)
         return;
 
     vtkSmartPointer<vtkPoints> vtkSmoothPoints = vtkSmartPointer<vtkPoints>::New(); //in smoothpoints the interpolated points representing a fiber are stored.
 
     //in vtkcells all polylines are stored, actually all id's of them are stored
     vtkSmartPointer<vtkCellArray> vtkSmoothCells = vtkSmartPointer<vtkCellArray>::New(); //cellcontainer for smoothed lines
     vtkIdType pointHelperCnt = 0;
 
     MITK_INFO << "Smoothing fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
         for (int j=0; j<numPoints; j++)
             newPoints->InsertNextPoint(points->GetPoint(j));
 
         float length = m_FiberLengths.at(i);
         int sampling = std::ceil(length/pointDistance);
 
         vtkSmartPointer<vtkKochanekSpline> xSpline = vtkSmartPointer<vtkKochanekSpline>::New();
         vtkSmartPointer<vtkKochanekSpline> ySpline = vtkSmartPointer<vtkKochanekSpline>::New();
         vtkSmartPointer<vtkKochanekSpline> zSpline = vtkSmartPointer<vtkKochanekSpline>::New();
         xSpline->SetDefaultBias(bias); xSpline->SetDefaultTension(tension); xSpline->SetDefaultContinuity(continuity);
         ySpline->SetDefaultBias(bias); ySpline->SetDefaultTension(tension); ySpline->SetDefaultContinuity(continuity);
         zSpline->SetDefaultBias(bias); zSpline->SetDefaultTension(tension); zSpline->SetDefaultContinuity(continuity);
 
         vtkSmartPointer<vtkParametricSpline> spline = vtkSmartPointer<vtkParametricSpline>::New();
         spline->SetXSpline(xSpline);
         spline->SetYSpline(ySpline);
         spline->SetZSpline(zSpline);
         spline->SetPoints(newPoints);
 
         vtkSmartPointer<vtkParametricFunctionSource> functionSource = vtkSmartPointer<vtkParametricFunctionSource>::New();
         functionSource->SetParametricFunction(spline);
         functionSource->SetUResolution(sampling);
         functionSource->SetVResolution(sampling);
         functionSource->SetWResolution(sampling);
         functionSource->Update();
 
         vtkPolyData* outputFunction = functionSource->GetOutput();
         vtkPoints* tmpSmoothPnts = outputFunction->GetPoints(); //smoothPoints of current fiber
 
         vtkSmartPointer<vtkPolyLine> smoothLine = vtkSmartPointer<vtkPolyLine>::New();
         smoothLine->GetPointIds()->SetNumberOfIds(tmpSmoothPnts->GetNumberOfPoints());
 
         for (int j=0; j<smoothLine->GetNumberOfPoints(); j++)
         {
             smoothLine->GetPointIds()->SetId(j, j+pointHelperCnt);
             vtkSmoothPoints->InsertNextPoint(tmpSmoothPnts->GetPoint(j));
         }
         vtkSmoothCells->InsertNextCell(smoothLine);
         pointHelperCnt += tmpSmoothPnts->GetNumberOfPoints();
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkSmoothPoints);
     m_FiberPolyData->SetLines(vtkSmoothCells);
     UpdateColorCoding();
     UpdateFiberGeometry();
     m_FiberSampling = 10/pointDistance;
 }
 
 void mitk::FiberBundleX::DoFiberSmoothing(float pointDistance)
 {
     DoFiberSmoothing(pointDistance, 0, 0, 0 );
 }
 
 // Resample fiber to get equidistant points
 void mitk::FiberBundleX::ResampleFibers(float pointDistance)
 {
     if (pointDistance<=0.00001)
         return;
 
     vtkSmartPointer<vtkPolyData> newPoly = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> newCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    newPoints = vtkSmartPointer<vtkPoints>::New();
 
     int numberOfLines = m_NumFibers;
 
     MITK_INFO << "Resampling fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<numberOfLines; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
         double* point = points->GetPoint(0);
         vtkIdType pointId = newPoints->InsertNextPoint(point);
         container->GetPointIds()->InsertNextId(pointId);
 
         float dtau = 0;
         int cur_p = 1;
         itk::Vector<float,3> dR;
         float normdR = 0;
 
         for (;;)
         {
             while (dtau <= pointDistance && cur_p < numPoints)
             {
                 itk::Vector<float,3> v1;
                 point = points->GetPoint(cur_p-1);
                 v1[0] = point[0];
                 v1[1] = point[1];
                 v1[2] = point[2];
                 itk::Vector<float,3> v2;
                 point = points->GetPoint(cur_p);
                 v2[0] = point[0];
                 v2[1] = point[1];
                 v2[2] = point[2];
 
                 dR  = v2 - v1;
                 normdR = std::sqrt(dR.GetSquaredNorm());
                 dtau += normdR;
                 cur_p++;
             }
 
             if (dtau >= pointDistance)
             {
                 itk::Vector<float,3> v1;
                 point = points->GetPoint(cur_p-1);
                 v1[0] = point[0];
                 v1[1] = point[1];
                 v1[2] = point[2];
 
                 itk::Vector<float,3> v2 = v1 - dR*( (dtau-pointDistance)/normdR );
                 pointId = newPoints->InsertNextPoint(v2.GetDataPointer());
                 container->GetPointIds()->InsertNextId(pointId);
             }
             else
             {
                 point = points->GetPoint(numPoints-1);
                 pointId = newPoints->InsertNextPoint(point);
                 container->GetPointIds()->InsertNextId(pointId);
                 break;
             }
             dtau = dtau-pointDistance;
         }
 
         newCellArray->InsertNextCell(container);
     }
 
     newPoly->SetPoints(newPoints);
     newPoly->SetLines(newCellArray);
     m_FiberPolyData = newPoly;
     UpdateFiberGeometry();
     UpdateColorCoding();
     m_FiberSampling = 10/pointDistance;
 }
 
 // reapply selected colorcoding in case polydata structure has changed
 void mitk::FiberBundleX::UpdateColorCoding()
 {
     char* cc = GetCurrentColorCoding();
 
     if( strcmp (COLORCODING_ORIENTATION_BASED,cc) == 0 )
         DoColorCodingOrientationBased();
     else if( strcmp (COLORCODING_FA_BASED,cc) == 0 )
         DoColorCodingFaBased();
 }
 
 // reapply selected colorcoding in case polydata structure has changed
 bool mitk::FiberBundleX::Equals(mitk::FiberBundleX* fib)
 {
     if (fib==NULL)
         return false;
 
     mitk::FiberBundleX::Pointer tempFib = this->SubtractBundle(fib);
     mitk::FiberBundleX::Pointer tempFib2 = fib->SubtractBundle(this);
 
     if (tempFib.IsNull() && tempFib2.IsNull())
         return true;
 
     return false;
 }
 
 /* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
 void mitk::FiberBundleX::UpdateOutputInformation()
 {
 
 }
 void mitk::FiberBundleX::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 bool mitk::FiberBundleX::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
     return false;
 }
 bool mitk::FiberBundleX::VerifyRequestedRegion()
 {
     return true;
 }
 void mitk::FiberBundleX::SetRequestedRegion(const itk::DataObject *data )
 {
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/FiberDirectionExtraction.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/FiberDirectionExtraction.cpp
index 35c676b599..3186c7c108 100755
--- a/Modules/DiffusionImaging/FiberTracking/MiniApps/FiberDirectionExtraction.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/FiberDirectionExtraction.cpp
@@ -1,169 +1,167 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "MiniAppManager.h"
 #include <mitkBaseDataIOFactory.h>
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkFiberTrackingObjectFactory.h>
 #include <metaCommand.h>
 #include "ctkCommandLineParser.h"
 #include <mitkAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
-#ifndef Q_MOC_RUN
-#  include <boost/lexical_cast.hpp>
-#endif 
+#include <boost/lexical_cast.hpp>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <itkTractsToVectorImageFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int FiberDirectionExtraction(int argc, char* argv[])
 {
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", ctkCommandLineParser::String, "input tractogram (.fib, vtk ascii file format)", mitk::Any(), false);
     parser.addArgument("out", "o", ctkCommandLineParser::String, "output root", mitk::Any(), false);
     parser.addArgument("mask", "m", ctkCommandLineParser::String, "mask image");
     parser.addArgument("athresh", "a", ctkCommandLineParser::Float, "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
     parser.addArgument("verbose", "v", ctkCommandLineParser::Bool, "output optional and intermediate calculation results");
 
     map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     string fibFile = mitk::any_cast<string>(parsedArgs["input"]);
 
     string maskImage("");
     if (parsedArgs.count("mask"))
         maskImage = mitk::any_cast<string>(parsedArgs["mask"]);
 
     float angularThreshold = 25;
     if (parsedArgs.count("athresh"))
         angularThreshold = mitk::any_cast<float>(parsedArgs["athresh"]);
 
     string outRoot = mitk::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = mitk::any_cast<bool>(parsedArgs["verbose"]);
 
 
     try
     {
         RegisterDiffusionCoreObjectFactory();
         RegisterFiberTrackingObjectFactory();
 
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
 
         // load fiber bundle
         mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         // load/create mask image
         ItkUcharImgType::Pointer itkMaskImage = NULL;
         if (maskImage.compare("")!=0)
         {
             MITK_INFO << "Using mask image";
             itkMaskImage = ItkUcharImgType::New();
             mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
             mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
         }
 
         // extract directions from fiber bundle
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(inputTractogram);
         fOdfFilter->SetMaskImage(itkMaskImage);
         fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
         fOdfFilter->SetNormalizeVectors(true);
         fOdfFilter->SetUseWorkingCopy(false);
         fOdfFilter->Update();
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
         // write direction images
         for (int i=0; i<directionImageContainer->Size(); i++)
         {
             itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
             typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
             WriterType::Pointer writer = WriterType::New();
 
             string outfilename = outRoot;
             outfilename.append("_DIRECTION_");
             outfilename.append(boost::lexical_cast<string>(i));
             outfilename.append(".nrrd");
 
             MITK_INFO << "writing " << outfilename;
             writer->SetFileName(outfilename.c_str());
             writer->SetInput(itkImg);
             writer->Update();
         }
 
         if (verbose)
         {
             // write vector field
             mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
             mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
             for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
             {
                 if ( (*it)->CanWriteBaseDataType(directions.GetPointer()) ) {
                     string outfilename = outRoot;
                     outfilename.append("_VECTOR_FIELD.fib");
                     (*it)->SetFileName( outfilename.c_str() );
                     (*it)->DoWrite( directions.GetPointer() );
                 }
             }
 
             // write num direction image
             {
                 ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
                 typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_NUM_DIRECTIONS.nrrd");
 
                 MITK_INFO << "writing " << outfilename;
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(numDirImage);
                 writer->Update();
             }
         }
 
         MITK_INFO << "DONE";
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 RegisterFiberTrackingMiniApp(FiberDirectionExtraction);
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/FiberProcessing.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/FiberProcessing.cpp
index 1a972bb143..ac38ea21eb 100644
--- a/Modules/DiffusionImaging/FiberTracking/MiniApps/FiberProcessing.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/FiberProcessing.cpp
@@ -1,162 +1,160 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "MiniAppManager.h"
 
 #include <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 #include <string>
 
 #include <itkImage.h>
 #include <itkImageFileReader.h>
 #include <itkExceptionObject.h>
 #include <itkImageFileWriter.h>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 #include <itkResampleImageFilter.h>
 
 #include <mitkBaseDataIOFactory.h>
 #include <mitkDiffusionImage.h>
 #include <mitkQBallImage.h>
 #include <mitkBaseData.h>
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkFiberTrackingObjectFactory.h>
 #include <mitkFiberBundleX.h>
 #include "ctkCommandLineParser.h"
-#ifndef Q_MOC_RUN
-#  include <boost/lexical_cast.hpp>
-#endif
+#include <boost/lexical_cast.hpp>
 
 /**
  * Short program to average redundant gradients in dwi-files
  */
 
 mitk::FiberBundleX::Pointer LoadFib(std::string filename)
 {
     const std::string s1="", s2="";
     std::vector<mitk::BaseData::Pointer> fibInfile = mitk::BaseDataIO::LoadBaseDataFromFile( filename, s1, s2, false );
     if( fibInfile.empty() )
         MITK_INFO << "File " << filename << " could not be read!";
 
     mitk::BaseData::Pointer baseData = fibInfile.at(0);
     return dynamic_cast<mitk::FiberBundleX*>(baseData.GetPointer());
 }
 
 int FiberProcessing(int argc, char* argv[])
 {
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", ctkCommandLineParser::String, "input fiber bundle (.fib)", mitk::Any(), false);
     parser.addArgument("outFile", "o", ctkCommandLineParser::String, "output fiber bundle (.fib)", mitk::Any(), false);
 
     parser.addArgument("resample", "r", ctkCommandLineParser::Float, "Resample fiber with the given point distance (in mm)");
     parser.addArgument("smooth", "s", ctkCommandLineParser::Float, "Smooth fiber with the given point distance (in mm)");
     parser.addArgument("minLength", "l", ctkCommandLineParser::Float, "Minimum fiber length (in mm)");
     parser.addArgument("maxLength", "m", ctkCommandLineParser::Float, "Maximum fiber length (in mm)");
     parser.addArgument("minCurv", "a", ctkCommandLineParser::Float, "Minimum curvature radius (in mm)");
     parser.addArgument("mirror", "p", ctkCommandLineParser::Int, "Invert fiber coordinates XYZ (e.g. 010 to invert y-coordinate of each fiber point)");
 
     map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     float pointDist = -1;
     if (parsedArgs.count("resample"))
         pointDist = mitk::any_cast<float>(parsedArgs["resample"]);
 
     float smoothDist = -1;
     if (parsedArgs.count("smooth"))
         smoothDist = mitk::any_cast<float>(parsedArgs["smooth"]);
 
     float minFiberLength = -1;
     if (parsedArgs.count("minLength"))
         minFiberLength = mitk::any_cast<float>(parsedArgs["minLength"]);
 
     float maxFiberLength = -1;
     if (parsedArgs.count("maxLength"))
         maxFiberLength = mitk::any_cast<float>(parsedArgs["maxLength"]);
 
     float curvThres = -1;
     if (parsedArgs.count("minCurv"))
         curvThres = mitk::any_cast<float>(parsedArgs["minCurv"]);
 
     int axis = 0;
     if (parsedArgs.count("mirror"))
         axis = mitk::any_cast<int>(parsedArgs["mirror"]);
 
     string inFileName = mitk::any_cast<string>(parsedArgs["input"]);
     string outFileName = mitk::any_cast<string>(parsedArgs["outFile"]);
 
     try
     {
         RegisterDiffusionCoreObjectFactory();
         RegisterFiberTrackingObjectFactory();
 
         mitk::FiberBundleX::Pointer fib = LoadFib(inFileName);
 
         if (minFiberLength>0)
             fib->RemoveShortFibers(minFiberLength);
 
         if (maxFiberLength>0)
             fib->RemoveLongFibers(maxFiberLength);
 
         if (curvThres>0)
             fib->ApplyCurvatureThreshold(curvThres, false);
 
         if (pointDist>0)
             fib->ResampleFibers(pointDist);
 
         if (smoothDist>0)
             fib->DoFiberSmoothing(smoothDist);
 
         if (axis/100==1)
             fib->MirrorFibers(0);
 
         if ((axis%100)/10==1)
             fib->MirrorFibers(1);
 
         if (axis%10==1)
             fib->MirrorFibers(2);
 
         mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
         for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
         {
             if ( (*it)->CanWriteBaseDataType(fib.GetPointer()) ) {
                 MITK_INFO << "writing " << outFileName;
                 (*it)->SetFileName( outFileName.c_str() );
                 (*it)->DoWrite( fib.GetPointer() );
             }
         }
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
 }
 RegisterFiberTrackingMiniApp(FiberProcessing);
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/GibbsTracking.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/GibbsTracking.cpp
index ff5d3adf0e..6b5ed9a955 100755
--- a/Modules/DiffusionImaging/FiberTracking/MiniApps/GibbsTracking.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/GibbsTracking.cpp
@@ -1,217 +1,215 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "MiniAppManager.h"
 
 #include <mitkImageCast.h>
 #include <mitkQBallImage.h>
 #include <mitkTensorImage.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkFiberTrackingObjectFactory.h>
 #include <mitkFiberBundleX.h>
 #include <itkGibbsTrackingFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkShCoefficientImageImporter.h>
 #include <mitkImageToItk.h>
 #include <mitkIOUtil.h>
 #include "ctkCommandLineParser.h"
-#ifndef Q_MOC_RUN
-#  include <boost/algorithm/string.hpp>
-#endif
+#include <boost/algorithm/string.hpp>
 
 template<int shOrder>
 typename itk::ShCoefficientImageImporter< float, shOrder >::QballImageType::Pointer TemplatedConvertShCoeffs(mitk::Image* mitkImg, int toolkit)
 {
     typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
     typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(mitkImg);
     caster->Update();
 
     typename FilterType::Pointer filter = FilterType::New();
     switch (toolkit)
     {
     case 0:
         filter->SetToolkit(FilterType::FSL);
         break;
     case 1:
         filter->SetToolkit(FilterType::MRTRIX);
         break;
     default:
         filter->SetToolkit(FilterType::FSL);
     }
     filter->SetInputImage(caster->GetOutput());
     filter->GenerateData();
     return filter->GetQballImage();
 }
 
 int GibbsTracking(int argc, char* argv[])
 {
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", ctkCommandLineParser::String, "input image (tensor, Q-ball or FSL/MRTrix SH-coefficient image)", mitk::Any(), false);
     parser.addArgument("parameters", "p", ctkCommandLineParser::String, "parameter file (.gtp)", mitk::Any(), false);
     parser.addArgument("mask", "m", ctkCommandLineParser::String, "binary mask image");
     parser.addArgument("shConvention", "s", ctkCommandLineParser::String, "sh coefficient convention (FSL, MRtrix)", string("FSL"), true);
     parser.addArgument("outFile", "o", ctkCommandLineParser::String, "output fiber bundle (.fib)", mitk::Any(), false);
 
     map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     string inFileName = mitk::any_cast<string>(parsedArgs["input"]);
     string paramFileName = mitk::any_cast<string>(parsedArgs["parameters"]);
     string outFileName = mitk::any_cast<string>(parsedArgs["outFile"]);
 
     try
     {
         RegisterDiffusionCoreObjectFactory();
         RegisterFiberTrackingObjectFactory();
 
         // instantiate gibbs tracker
         typedef itk::Vector<float, QBALL_ODFSIZE>   OdfVectorType;
         typedef itk::Image<OdfVectorType,3>         ItkQballImageType;
         typedef itk::GibbsTrackingFilter<ItkQballImageType> GibbsTrackingFilterType;
         GibbsTrackingFilterType::Pointer gibbsTracker = GibbsTrackingFilterType::New();
 
         // load input image
         const std::string s1="", s2="";
         std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
 
         // try to cast to qball image
         if( boost::algorithm::ends_with(inFileName, ".qbi") )
         {
             MITK_INFO << "Loading qball image ...";
             mitk::QBallImage::Pointer mitkQballImage = dynamic_cast<mitk::QBallImage*>(infile.at(0).GetPointer());
             ItkQballImageType::Pointer itk_qbi = ItkQballImageType::New();
             mitk::CastToItkImage<ItkQballImageType>(mitkQballImage, itk_qbi);
             gibbsTracker->SetQBallImage(itk_qbi.GetPointer());
         }
         else if( boost::algorithm::ends_with(inFileName, ".dti") )
         {
             MITK_INFO << "Loading tensor image ...";
             typedef itk::Image< itk::DiffusionTensor3D<float>, 3 >    ItkTensorImage;
             mitk::TensorImage::Pointer mitkTensorImage = dynamic_cast<mitk::TensorImage*>(infile.at(0).GetPointer());
             ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
             mitk::CastToItkImage<ItkTensorImage>(mitkTensorImage, itk_dti);
             gibbsTracker->SetTensorImage(itk_dti);
         }
         else if ( boost::algorithm::ends_with(inFileName, ".nii") )
         {
             MITK_INFO << "Loading sh-coefficient image ...";
             mitk::Image::Pointer mitkImage = dynamic_cast<mitk::Image*>(infile.at(0).GetPointer());
 
             int nrCoeffs = mitkImage->GetLargestPossibleRegion().GetSize()[3];
             int c=3, d=2-2*nrCoeffs;
             double D = c*c-4*d;
             int shOrder;
             if (D>0)
             {
                 shOrder = (-c+sqrt(D))/2.0;
                 if (shOrder<0)
                     shOrder = (-c-sqrt(D))/2.0;
             }
             else if (D==0)
                 shOrder = -c/2.0;
 
             MITK_INFO << "using SH-order " << shOrder;
 
             int toolkitConvention = 0;
 
             if (parsedArgs.count("shConvention"))
             {
                 string convention = mitk::any_cast<string>(parsedArgs["shConvention"]).c_str();
 
                 if ( boost::algorithm::equals(convention, "MRtrix") )
                 {
                     toolkitConvention = 1;
                     MITK_INFO << "Using MRtrix style sh-coefficient convention";
                 }
                 else
                     MITK_INFO << "Using FSL style sh-coefficient convention";
             }
             else
                 MITK_INFO << "Using FSL style sh-coefficient convention";
 
             switch (shOrder)
             {
             case 4:
                 gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<4>(mitkImage, toolkitConvention));
                 break;
             case 6:
                 gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<6>(mitkImage, toolkitConvention));
                 break;
             case 8:
                 gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<8>(mitkImage, toolkitConvention));
                 break;
             case 10:
                 gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<10>(mitkImage, toolkitConvention));
                 break;
             case 12:
                 gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<12>(mitkImage, toolkitConvention));
                 break;
             default:
                 MITK_INFO << "SH-order " << shOrder << " not supported";
             }
         }
         else
             return EXIT_FAILURE;
 
         // global tracking
         if (parsedArgs.count("mask"))
         {
             typedef itk::Image<float,3> MaskImgType;
             mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(mitk::any_cast<string>(parsedArgs["mask"]));
             MaskImgType::Pointer itk_mask = MaskImgType::New();
             mitk::CastToItkImage<MaskImgType>(mitkMaskImage, itk_mask);
             gibbsTracker->SetMaskImage(itk_mask);
         }
 
         gibbsTracker->SetDuplicateImage(false);
         gibbsTracker->SetLoadParameterFile( paramFileName );
 //        gibbsTracker->SetLutPath( "" );
         gibbsTracker->Update();
 
         mitk::FiberBundleX::Pointer mitkFiberBundle = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
 
         mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
         for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
         {
             if ( (*it)->CanWriteBaseDataType(mitkFiberBundle.GetPointer()) ) {
                 (*it)->SetFileName( outFileName.c_str() );
                 (*it)->DoWrite( mitkFiberBundle.GetPointer() );
             }
         }
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 RegisterFiberTrackingMiniApp(GibbsTracking);
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/PeakExtraction.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/PeakExtraction.cpp
index 67f36c2d23..21d387709e 100755
--- a/Modules/DiffusionImaging/FiberTracking/MiniApps/PeakExtraction.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/PeakExtraction.cpp
@@ -1,353 +1,351 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "MiniAppManager.h"
 
 #include <itkImageFileWriter.h>
 #include <itkResampleImageFilter.h>
 #include <itkFiniteDiffOdfMaximaExtractionFilter.h>
 
 #include <mitkBaseDataIOFactory.h>
 #include <mitkDiffusionImage.h>
 #include <mitkQBallImage.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkCoreExtObjectFactory.h>
 #include <mitkCoreObjectFactory.h>
 #include "ctkCommandLineParser.h"
 #include <mitkFiberBundleXWriter.h>
 #include <itkShCoefficientImageImporter.h>
 #include <mitkNrrdQBallImageWriter.h>
 #include <itkFlipImageFilter.h>
-#ifndef Q_MOC_RUN
-#  include <boost/lexical_cast.hpp>
-#  include <boost/algorithm/string.hpp>
-#endif
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
 
 
 mitk::Image::Pointer LoadData(std::string filename)
 {
     if( filename.empty() )
         return NULL;
 
     const std::string s1="", s2="";
     std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( filename, s1, s2, false );
     if( infile.empty() )
     {
         MITK_INFO << "File " << filename << " could not be read!";
         return NULL;
     }
 
     mitk::BaseData::Pointer baseData = infile.at(0);
     return dynamic_cast<mitk::Image*>(baseData.GetPointer());
 }
 
 int PeakExtraction(int argc, char* argv[])
 {
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("image", "i", ctkCommandLineParser::String, "sh coefficient image", mitk::Any(), false);
     parser.addArgument("outroot", "o", ctkCommandLineParser::String, "output root", mitk::Any(), false);
     parser.addArgument("mask", "m", ctkCommandLineParser::String, "mask image");
     parser.addArgument("normalization", "n", ctkCommandLineParser::Int, "0=no norm, 1=max norm, 2=single vec norm", 1, true);
     parser.addArgument("numpeaks", "p", ctkCommandLineParser::Int, "maximum number of extracted peaks", 2, true);
     parser.addArgument("peakthres", "r", ctkCommandLineParser::Float, "peak threshold relative to largest peak", 0.4, true);
     parser.addArgument("abspeakthres", "a", ctkCommandLineParser::Float, "absolute peak threshold weighted with local GFA value", 0.06, true);
     parser.addArgument("shConvention", "s", ctkCommandLineParser::String, "use specified SH-basis (MITK, FSL, MRtrix)", string("MITK"), true);
     parser.addArgument("noFlip", "f", ctkCommandLineParser::Bool, "do not flip input image to match MITK coordinate convention");
 
     map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     // mandatory arguments
     string imageName = mitk::any_cast<string>(parsedArgs["image"]);
     string outRoot = mitk::any_cast<string>(parsedArgs["outroot"]);
 
     // optional arguments
     string maskImageName("");
     if (parsedArgs.count("mask"))
         maskImageName = mitk::any_cast<string>(parsedArgs["mask"]);
 
     int normalization = 1;
     if (parsedArgs.count("normalization"))
         normalization = mitk::any_cast<int>(parsedArgs["normalization"]);
 
     int numPeaks = 2;
     if (parsedArgs.count("numpeaks"))
         numPeaks = mitk::any_cast<int>(parsedArgs["numpeaks"]);
 
     float peakThres = 0.4;
     if (parsedArgs.count("peakthres"))
         peakThres = mitk::any_cast<float>(parsedArgs["peakthres"]);
 
     float absPeakThres = 0.06;
     if (parsedArgs.count("abspeakthres"))
         absPeakThres = mitk::any_cast<float>(parsedArgs["abspeakthres"]);
 
     bool noFlip = false;
     if (parsedArgs.count("noFlip"))
         noFlip = mitk::any_cast<bool>(parsedArgs["noFlip"]);
 
     MITK_INFO << "image: " << imageName;
     MITK_INFO << "outroot: " << outRoot;
     if (!maskImageName.empty())
         MITK_INFO << "mask: " << maskImageName;
     else
         MITK_INFO << "no mask image selected";
     MITK_INFO << "numpeaks: " << numPeaks;
     MITK_INFO << "peakthres: " << peakThres;
     MITK_INFO << "abspeakthres: " << absPeakThres;
 
     try
     {
         mitk::CoreObjectFactory::GetInstance();
 
         RegisterDiffusionCoreObjectFactory();
 
         mitk::Image::Pointer image = LoadData(imageName);
         mitk::Image::Pointer mask = LoadData(maskImageName);
 
         typedef itk::Image<unsigned char, 3>  ItkUcharImgType;
         typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, 4, 20242 > MaximaExtractionFilterType;
         MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
         int toolkitConvention = 0;
 
         if (parsedArgs.count("shConvention"))
         {
             string convention = mitk::any_cast<string>(parsedArgs["shConvention"]).c_str();
             if ( boost::algorithm::equals(convention, "FSL") )
             {
                 toolkitConvention = 1;
                 MITK_INFO << "Using FSL SH-basis";
             }
             else if ( boost::algorithm::equals(convention, "MRtrix") )
             {
                 toolkitConvention = 2;
                 MITK_INFO << "Using MRtrix SH-basis";
             }
             else
                 MITK_INFO << "Using MITK SH-basis";
         }
         else
             MITK_INFO << "Using MITK SH-basis";
 
         ItkUcharImgType::Pointer itkMaskImage = NULL;
         if (mask.IsNotNull())
         {
             try{
                 itkMaskImage = ItkUcharImgType::New();
                 mitk::CastToItkImage<ItkUcharImgType>(mask, itkMaskImage);
                 filter->SetMaskImage(itkMaskImage);
             }
             catch(...)
             {
 
             }
         }
 
         if (toolkitConvention>0)
         {
             MITK_INFO << "Converting coefficient image to MITK format";
             typedef itk::ShCoefficientImageImporter< float, 4 > ConverterType;
             typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
             CasterType::Pointer caster = CasterType::New();
             caster->SetInput(image);
             caster->Update();
             itk::Image< float, 4 >::Pointer itkImage = caster->GetOutput();
 
             ConverterType::Pointer converter = ConverterType::New();
 
             if (noFlip)
             {
                 converter->SetInputImage(itkImage);
             }
             else
             {
                 itk::FixedArray<bool, 4> flipAxes;
                 flipAxes[0] = true;
                 flipAxes[1] = true;
                 flipAxes[2] = false;
                 flipAxes[3] = false;
                 itk::FlipImageFilter< itk::Image< float, 4 > >::Pointer flipper = itk::FlipImageFilter< itk::Image< float, 4 > >::New();
                 flipper->SetInput(itkImage);
                 flipper->SetFlipAxes(flipAxes);
                 flipper->Update();
                 itk::Image< float, 4 >::Pointer flipped = flipper->GetOutput();
                 flipped->SetDirection(itkImage->GetDirection());
                 flipped->SetOrigin(itkImage->GetOrigin());
 
                 converter->SetInputImage(flipped);
             }
 
             switch (toolkitConvention)
             {
             case 1:
                 converter->SetToolkit(ConverterType::FSL);
                 filter->SetToolkit(MaximaExtractionFilterType::FSL);
                 break;
             case 2:
                 converter->SetToolkit(ConverterType::MRTRIX);
                 filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
                 break;
             default:
                 converter->SetToolkit(ConverterType::FSL);
                 filter->SetToolkit(MaximaExtractionFilterType::FSL);
                 break;
             }
             converter->GenerateData();
             filter->SetInput(converter->GetCoefficientImage());
 
             // write qbi
             ConverterType::QballImageType::Pointer itkQbi = converter->GetQballImage();
 
             if (itkMaskImage.IsNotNull())
             {
                 itkQbi->SetDirection(itkMaskImage->GetDirection());
                 itkQbi->SetOrigin(itkMaskImage->GetOrigin());
             }
 
             mitk::QBallImage::Pointer mitkQbi = mitk::QBallImage::New();
             mitkQbi->InitializeByItk( itkQbi.GetPointer() );
             mitkQbi->SetVolume( itkQbi->GetBufferPointer() );
 
             string outfilename = outRoot;
             outfilename.append("_QBI.qbi");
             MITK_INFO << "writing " << outfilename;
 
             mitk::NrrdQBallImageWriter::Pointer writer = mitk::NrrdQBallImageWriter::New();
             writer->SetFileName(outfilename.c_str());
             writer->DoWrite(mitkQbi.GetPointer());
         }
         else
         {
             try{
                 typedef mitk::ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(image);
                 caster->Update();
                 filter->SetInput(caster->GetOutput());
             }
             catch(...)
             {
                 MITK_INFO << "wrong image type";
                 return EXIT_FAILURE;
             }
         }
 
         filter->SetMaxNumPeaks(numPeaks);
         filter->SetPeakThreshold(peakThres);
         filter->SetAbsolutePeakThreshold(absPeakThres);
         filter->SetAngularThreshold(1);
 
         switch (normalization)
         {
         case 0:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
             break;
         case 1:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
             break;
         case 2:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
             break;
         }
 
         filter->Update();
 
         // write direction images
         {
             typedef MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
             ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
             for (int i=0; i<container->Size(); i++)
             {
                 MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
 
                 if (itkMaskImage.IsNotNull())
                 {
                     itkImg->SetDirection(itkMaskImage->GetDirection());
                     itkImg->SetOrigin(itkMaskImage->GetOrigin());
                 }
 
                 string outfilename = outRoot;
                 outfilename.append("_DIRECTION_");
                 outfilename.append(boost::lexical_cast<string>(i));
                 outfilename.append(".nrrd");
 
                 MITK_INFO << "writing " << outfilename;
                 typedef itk::ImageFileWriter< MaximaExtractionFilterType::ItkDirectionImage > WriterType;
                 WriterType::Pointer writer = WriterType::New();
                 writer->SetFileName(outfilename);
                 writer->SetInput(itkImg);
                 writer->Update();
             }
         }
 
         // write num directions image
         {
             ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
 
             if (itkMaskImage.IsNotNull())
             {
                 numDirImage->SetDirection(itkMaskImage->GetDirection());
                 numDirImage->SetOrigin(itkMaskImage->GetOrigin());
             }
 
             string outfilename = outRoot.c_str();
             outfilename.append("_NUM_DIRECTIONS.nrrd");
             MITK_INFO << "writing " << outfilename;
             typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
             WriterType::Pointer writer = WriterType::New();
             writer->SetFileName(outfilename);
             writer->SetInput(numDirImage);
             writer->Update();
         }
 
         // write vector field
         {
             mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
 
             string outfilename = outRoot.c_str();
             outfilename.append("_VECTOR_FIELD.fib");
 
             mitk::FiberBundleXWriter::Pointer fibWriter = mitk::FiberBundleXWriter::New();
             fibWriter->SetFileName(outfilename.c_str());
             fibWriter->DoWrite(directions.GetPointer());
         }
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
     MITK_INFO << "DONE";
     return EXIT_SUCCESS;
 }
 RegisterFiberTrackingMiniApp(PeakExtraction);
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/TractogramAngularError.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/TractogramAngularError.cpp
index 42a3f1a0ce..5e70d879c7 100755
--- a/Modules/DiffusionImaging/FiberTracking/MiniApps/TractogramAngularError.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/TractogramAngularError.cpp
@@ -1,207 +1,205 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "MiniAppManager.h"
 #include <mitkBaseDataIOFactory.h>
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkFiberTrackingObjectFactory.h>
 #include <metaCommand.h>
 #include "ctkCommandLineParser.h"
 #include <mitkAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
-#ifndef Q_MOC_RUN
-#  include <boost/lexical_cast.hpp>
-#endif
+#include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 #include <itkEvaluateTractogramDirectionsFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int TractogramAngularError(int argc, char* argv[])
 {
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", ctkCommandLineParser::String, "input tractogram (.fib, vtk ascii file format)", mitk::Any(), false);
     parser.addArgument("reference", "r", ctkCommandLineParser::StringList, "reference direction images", mitk::Any(), false);
     parser.addArgument("out", "o", ctkCommandLineParser::String, "output root", mitk::Any(), false);
     parser.addArgument("mask", "m", ctkCommandLineParser::String, "mask image");
     parser.addArgument("verbose", "v", ctkCommandLineParser::Bool, "output optional and intermediate calculation results");
     parser.addArgument("ignore", "n", ctkCommandLineParser::Bool, "don't increase error for missing or too many directions");
     parser.addArgument("trilinear", "t", ctkCommandLineParser::Bool, "use trilinear instead of nearest neighbor interpolation");
 
     map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     ctkCommandLineParser::StringContainerType referenceImages = mitk::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
 
     string fibFile = mitk::any_cast<string>(parsedArgs["input"]);
 
     string maskImage("");
     if (parsedArgs.count("mask"))
         maskImage = mitk::any_cast<string>(parsedArgs["mask"]);
 
     string outRoot = mitk::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = mitk::any_cast<bool>(parsedArgs["verbose"]);
 
     bool ignore = false;
     if (parsedArgs.count("ignore"))
         ignore = mitk::any_cast<bool>(parsedArgs["ignore"]);
 
     bool interpolate = false;
     if (parsedArgs.count("interpolate"))
         interpolate = mitk::any_cast<bool>(parsedArgs["interpolate"]);
 
     try
     {
         RegisterDiffusionCoreObjectFactory();
         RegisterFiberTrackingObjectFactory();
 
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
         typedef itk::EvaluateTractogramDirectionsFilter< float >                EvaluationFilterType;
 
         // load fiber bundle
         mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
         if (!inputTractogram)
             return EXIT_FAILURE;
 
         // load reference directions
         ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
         for (int i=0; i<referenceImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
             }
             catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
         }
 
         // load/create mask image
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         if (maskImage.compare("")==0)
         {
             ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
             itkMaskImage->SetSpacing( dirImg->GetSpacing() );
             itkMaskImage->SetOrigin( dirImg->GetOrigin() );
             itkMaskImage->SetDirection( dirImg->GetDirection() );
             itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->Allocate();
             itkMaskImage->FillBuffer(1);
         }
         else
         {
             mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
             mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
         }
 
         // evaluate directions
         EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
         evaluationFilter->SetTractogram(inputTractogram);
         evaluationFilter->SetReferenceImageSet(referenceImageContainer);
         evaluationFilter->SetMaskImage(itkMaskImage);
         evaluationFilter->SetIgnoreMissingDirections(ignore);
         evaluationFilter->SetUseInterpolation(interpolate);
         evaluationFilter->Update();
 
         if (verbose)
         {
             EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
             typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
             WriterType::Pointer writer = WriterType::New();
 
             string outfilename = outRoot;
             outfilename.append("_ERROR_IMAGE.nrrd");
 
             MITK_INFO << "writing " << outfilename;
             writer->SetFileName(outfilename.c_str());
             writer->SetInput(angularErrorImage);
             writer->Update();
         }
 
         string logFile = outRoot;
         logFile.append("_ANGULAR_ERROR.csv");
 
         ofstream file;
         file.open (logFile.c_str());
 
         string sens = "Mean:";
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
         sens.append(";\n");
 
         sens.append("Median:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
         sens.append(";\n");
 
         sens.append("Maximum:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
         sens.append(";\n");
 
         sens.append("Minimum:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
         sens.append(";\n");
 
         sens.append("STDEV:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
         sens.append(";\n");
 
         file << sens;
 
         file.close();
 
         MITK_INFO << "DONE";
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 RegisterFiberTrackingMiniApp(TractogramAngularError);
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp
index 089cc4d826..78297e6f0c 100755
--- a/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp
@@ -1,266 +1,264 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "MiniAppManager.h"
 #include <mitkBaseDataIOFactory.h>
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkFiberTrackingObjectFactory.h>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <metaCommand.h>
 #include "ctkCommandLineParser.h"
 #include "ctkCommandLineParser.cpp"
 #include <itkTractsToVectorImageFilter.h>
 #include <mitkAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
-#ifndef Q_MOC_RUN
-#  include <boost/lexical_cast.hpp>
-#endif
+#include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int TractometerAngularErrorTool(int argc, char* argv[])
 {
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", ctkCommandLineParser::String, "input tractogram (.fib, vtk ascii file format)", mitk::Any(), false);
     parser.addArgument("reference", "r", ctkCommandLineParser::StringList, "reference direction images", mitk::Any(), false);
     parser.addArgument("out", "o", ctkCommandLineParser::String, "output root", mitk::Any(), false);
     parser.addArgument("mask", "m", ctkCommandLineParser::String, "mask image");
     parser.addArgument("athresh", "a", ctkCommandLineParser::Float, "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
     parser.addArgument("verbose", "v", ctkCommandLineParser::Bool, "output optional and intermediate calculation results");
     parser.addArgument("ignore", "n", ctkCommandLineParser::Bool, "don't increase error for missing or too many directions");
 
     map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     ctkCommandLineParser::StringContainerType referenceImages = mitk::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
 
     string fibFile = mitk::any_cast<string>(parsedArgs["input"]);
 
     string maskImage("");
     if (parsedArgs.count("mask"))
         maskImage = mitk::any_cast<string>(parsedArgs["mask"]);
 
     float angularThreshold = 25;
     if (parsedArgs.count("athresh"))
         angularThreshold = mitk::any_cast<float>(parsedArgs["athresh"]);
 
     string outRoot = mitk::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = mitk::any_cast<bool>(parsedArgs["verbose"]);
 
     bool ignore = false;
     if (parsedArgs.count("ignore"))
         ignore = mitk::any_cast<bool>(parsedArgs["ignore"]);
 
     try
     {
         RegisterDiffusionCoreObjectFactory();
         RegisterFiberTrackingObjectFactory();
 
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
         typedef itk::EvaluateDirectionImagesFilter< float >                     EvaluationFilterType;
 
         // load fiber bundle
         mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         // load reference directions
         ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
         for (int i=0; i<referenceImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
             }
             catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
         }
 
         // load/create mask image
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         if (maskImage.compare("")==0)
         {
             ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
             itkMaskImage->SetSpacing( dirImg->GetSpacing() );
             itkMaskImage->SetOrigin( dirImg->GetOrigin() );
             itkMaskImage->SetDirection( dirImg->GetDirection() );
             itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->Allocate();
             itkMaskImage->FillBuffer(1);
         }
         else
         {
             mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
             mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
         }
 
 
         // extract directions from fiber bundle
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(inputTractogram);
         fOdfFilter->SetMaskImage(itkMaskImage);
         fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
         fOdfFilter->SetNormalizeVectors(true);
         fOdfFilter->SetUseWorkingCopy(false);
         fOdfFilter->Update();
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
         if (verbose)
         {
             // write vector field
             mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
             mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
             for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
             {
                 if ( (*it)->CanWriteBaseDataType(directions.GetPointer()) ) {
                     string outfilename = outRoot;
                     outfilename.append("_VECTOR_FIELD.fib");
                     (*it)->SetFileName( outfilename.c_str() );
                     (*it)->DoWrite( directions.GetPointer() );
                 }
             }
 
             // write direction images
             for (int i=0; i<directionImageContainer->Size(); i++)
             {
                 itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
                 typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_DIRECTION_");
                 outfilename.append(boost::lexical_cast<string>(i));
                 outfilename.append(".nrrd");
 
                 MITK_INFO << "writing " << outfilename;
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(itkImg);
                 writer->Update();
             }
 
             // write num direction image
             {
                 ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
                 typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_NUM_DIRECTIONS.nrrd");
 
                 MITK_INFO << "writing " << outfilename;
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(numDirImage);
                 writer->Update();
             }
         }
 
         // evaluate directions
         EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
         evaluationFilter->SetImageSet(directionImageContainer);
         evaluationFilter->SetReferenceImageSet(referenceImageContainer);
         evaluationFilter->SetMaskImage(itkMaskImage);
         evaluationFilter->SetIgnoreMissingDirections(ignore);
         evaluationFilter->Update();
 
         if (verbose)
         {
             EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
             typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
             WriterType::Pointer writer = WriterType::New();
 
             string outfilename = outRoot;
             outfilename.append("_ERROR_IMAGE.nrrd");
 
             MITK_INFO << "writing " << outfilename;
             writer->SetFileName(outfilename.c_str());
             writer->SetInput(angularErrorImage);
             writer->Update();
         }
 
         string logFile = outRoot;
         logFile.append("_ANGULAR_ERROR.csv");
 
         ofstream file;
         file.open (logFile.c_str());
 
         string sens = "Mean:";
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
         sens.append(";\n");
 
         sens.append("Median:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
         sens.append(";\n");
 
         sens.append("Maximum:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
         sens.append(";\n");
 
         sens.append("Minimum:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
         sens.append(";\n");
 
         sens.append("STDEV:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
         sens.append(";\n");
 
         file << sens;
 
         file.close();
 
         MITK_INFO << "DONE";
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 RegisterFiberTrackingMiniApp(TractometerAngularErrorTool);
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
index fbf3a37916..a790432044 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
@@ -1,162 +1,160 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef __mitkNrrdTbssImageWriter__cpp
 #define __mitkNrrdTbssImageWriter__cpp
 
 #include "mitkNrrdTbssImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 //#include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
-#ifndef Q_MOC_RUN
-#  include "boost/lexical_cast.hpp"
-#endif
+#include "boost/lexical_cast.hpp"
 
 #include <iostream>
 #include <fstream>
 
 
 mitk::NrrdTbssImageWriter::NrrdTbssImageWriter()
   : m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
 {
   this->SetNumberOfRequiredInputs( 1 );
 }
 
 mitk::NrrdTbssImageWriter::~NrrdTbssImageWriter()
 {}
 
 
 void mitk::NrrdTbssImageWriter::GenerateData()
 {
   m_Success = false;
   InputType* input = this->GetInput();
   if (input == NULL)
   {
     itkWarningMacro(<<"Sorry, input to NrrdTbssImageWriter is NULL!");
     return;
   }
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
 
 
   itk::VectorImage<float, 3>::Pointer img = input->GetImage();
 
 
 
 
   std::string key;
   std::string val;
 
 
   /* For the case of a tbss image containing data of the patients:
      Save info about the groups and the type of measurement */
 
 
 
 
   std::vector< std::pair <std::string, int> > groups = input->GetGroupInfo();
   std::vector< std::pair <std::string, int> >::iterator it = groups.begin();
 
   int i=0;
   while(it != groups.end())
   {
     std::pair<std::string, int> p = *it;
 
     key = "Group_index_" + boost::lexical_cast<std::string>(i);
     val = " " + p.first + " " + boost::lexical_cast<std::string>(p.second);
     //sprintf( keybuffer, "Group_index_%04d", std::string(i) );
     // sprintf( valbuffer, "%1d %1d", p.first, p.second);
 
     //std::cout << valbuffer << std::endl;
 
     //itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
     itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
     it++;
     ++i;
   }
 
   key = "Measurement info";
   val = input->GetMeasurementInfo();
   itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
 
 
 
 
 
   typedef itk::VectorImage<float,3> ImageType;
 
   itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
   io->SetFileType( itk::ImageIOBase::Binary );
   io->UseCompressionOn();
 
 
   typedef itk::ImageFileWriter<ImageType> WriterType;
   WriterType::Pointer nrrdWriter = WriterType::New();
   nrrdWriter->UseInputMetaDataDictionaryOn();
   nrrdWriter->SetInput( img );
   nrrdWriter->SetImageIO(io);
   nrrdWriter->SetFileName(m_FileName);
   nrrdWriter->UseCompressionOn();
   nrrdWriter->SetImageIO(io);
   try
   {
     nrrdWriter->Update();
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e << std::endl;
   }
 
   m_Success = true;
 }
 
 
 
 
 void mitk::NrrdTbssImageWriter::SetInput( InputType* tbssVol )
 {
   this->ProcessObject::SetNthInput( 0, tbssVol );
 }
 
 
 mitk::TbssImage* mitk::NrrdTbssImageWriter::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return NULL;
   }
   else
   {
     return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 
 std::vector<std::string> mitk::NrrdTbssImageWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".tbss");
   return possibleFileExtensions;
 }
 
 #endif //__mitkNrrdTbssImageWriter__cpp
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
index 413673331c..67a4c2d71a 100755
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,1993 +1,1991 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberfoxView.h"
 
 // MITK
 #include <mitkImage.h>
 #include <mitkDiffusionImage.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkDataStorage.h>
 #include <itkFibersFromPlanarFiguresFilter.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkTensorImage.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkImageGenerator.h>
 #include <mitkNodePredicateDataType.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <itkAddArtifactsToDwiImageFilter.h>
-#ifndef Q_MOC_RUN
-#  include <boost/property_tree/ptree.hpp>
-#  include <boost/property_tree/xml_parser.hpp>
-#  include <boost/foreach.hpp>
-#endif
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/foreach.hpp>
 #include <QFileDialog>
 #include <QMessageBox>
 #include "usModuleRegistry.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 const std::string QmitkFiberfoxView::VIEW_ID = "org.mitk.views.fiberfoxview";
 
 QmitkFiberfoxView::QmitkFiberfoxView()
     : QmitkAbstractView()
     , m_Controls( 0 )
     , m_SelectedImage( NULL )
 {
 
 }
 
 // Destructor
 QmitkFiberfoxView::~QmitkFiberfoxView()
 {
 
 }
 
 void QmitkFiberfoxView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberfoxViewControls;
         m_Controls->setupUi( parent );
 
         m_Controls->m_StickWidget1->setVisible(true);
         m_Controls->m_StickWidget2->setVisible(false);
         m_Controls->m_ZeppelinWidget1->setVisible(false);
         m_Controls->m_ZeppelinWidget2->setVisible(false);
         m_Controls->m_TensorWidget1->setVisible(false);
         m_Controls->m_TensorWidget2->setVisible(false);
 
         m_Controls->m_BallWidget1->setVisible(true);
         m_Controls->m_BallWidget2->setVisible(false);
         m_Controls->m_AstrosticksWidget1->setVisible(false);
         m_Controls->m_AstrosticksWidget2->setVisible(false);
         m_Controls->m_DotWidget1->setVisible(false);
         m_Controls->m_DotWidget2->setVisible(false);
 
         m_Controls->m_Comp4FractionFrame->setVisible(false);
         m_Controls->m_DiffusionPropsMessage->setVisible(false);
         m_Controls->m_GeometryMessage->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_VarianceBox->setVisible(false);
         m_Controls->m_GibbsRingingFrame->setVisible(false);
         m_Controls->m_NoiseFrame->setVisible(false);
         m_Controls->m_GhostFrame->setVisible(false);
         m_Controls->m_DistortionsFrame->setVisible(false);
         m_Controls->m_EddyFrame->setVisible(false);
 
         m_Controls->m_FrequencyMapBox->SetDataStorage(this->GetDataStorage());
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
         mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
         mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
         mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
         isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         m_Controls->m_FrequencyMapBox->SetPredicate(finalPredicate);
 
         connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
         connect((QObject*) m_Controls->m_GenerateFibersButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFibers()));
         connect((QObject*) m_Controls->m_CircleButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnDrawROI()));
         connect((QObject*) m_Controls->m_FlipButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnFlipButton()));
         connect((QObject*) m_Controls->m_JoinBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(JoinBundles()));
         connect((QObject*) m_Controls->m_VarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
         connect((QObject*) m_Controls->m_DistributionBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnDistributionChanged(int)));
         connect((QObject*) m_Controls->m_FiberDensityBox, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(OnFiberDensityChanged(int)));
         connect((QObject*) m_Controls->m_FiberSamplingBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnFiberSamplingChanged(double)));
         connect((QObject*) m_Controls->m_TensionBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnTensionChanged(double)));
         connect((QObject*) m_Controls->m_ContinuityBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnContinuityChanged(double)));
         connect((QObject*) m_Controls->m_BiasBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnBiasChanged(double)));
         connect((QObject*) m_Controls->m_AddGibbsRinging, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGibbsRinging(int)));
         connect((QObject*) m_Controls->m_AddNoise, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddNoise(int)));
         connect((QObject*) m_Controls->m_AddGhosts, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGhosts(int)));
         connect((QObject*) m_Controls->m_AddDistortions, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddDistortions(int)));
         connect((QObject*) m_Controls->m_AddEddy, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddEddy(int)));
 
         connect((QObject*) m_Controls->m_ConstantRadiusBox, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnConstantRadius(int)));
         connect((QObject*) m_Controls->m_CopyBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(CopyBundles()));
         connect((QObject*) m_Controls->m_TransformBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(ApplyTransform()));
         connect((QObject*) m_Controls->m_AlignOnGrid, SIGNAL(clicked()), (QObject*) this, SLOT(AlignOnGrid()));
 
         connect((QObject*) m_Controls->m_Compartment1Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp1ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment2Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp2ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment3Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp3ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment4Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp4ModelFrameVisibility(int)));
 
         connect((QObject*) m_Controls->m_AdvancedOptionsBox, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
         connect((QObject*) m_Controls->m_AdvancedOptionsBox_2, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
 
         connect((QObject*) m_Controls->m_SaveParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(SaveParameters()));
         connect((QObject*) m_Controls->m_LoadParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(LoadParameters()));
     }
 }
 
 void QmitkFiberfoxView::UpdateImageParameters()
 {
     m_ImageGenParameters.artifactList.clear();
     m_ImageGenParameters.nonFiberModelList.clear();
     m_ImageGenParameters.fiberModelList.clear();
     m_ImageGenParameters.signalModelString = "";
     m_ImageGenParameters.artifactModelString = "";
     m_ImageGenParameters.resultNode = mitk::DataNode::New();
     m_ImageGenParameters.tissueMaskImage = NULL;
     m_ImageGenParameters.frequencyMap = NULL;
     m_ImageGenParameters.gradientDirections.clear();
 
     if (m_SelectedDWI.IsNotNull())  // use parameters of selected DWI
     {
         mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedDWI->GetData());
         m_ImageGenParameters.imageRegion = dwi->GetVectorImage()->GetLargestPossibleRegion();
         m_ImageGenParameters.imageSpacing = dwi->GetVectorImage()->GetSpacing();
         m_ImageGenParameters.imageOrigin = dwi->GetVectorImage()->GetOrigin();
         m_ImageGenParameters.imageDirection = dwi->GetVectorImage()->GetDirection();
         m_ImageGenParameters.b_value = dwi->GetB_Value();
         mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer dirs = dwi->GetDirections();
 
         m_ImageGenParameters.numGradients = 0;
         for (int i=0; i<dirs->Size(); i++)
         {
             DiffusionSignalModel<double>::GradientType g;
             g[0] = dirs->at(i)[0];
             g[1] = dirs->at(i)[1];
             g[2] = dirs->at(i)[2];
             m_ImageGenParameters.gradientDirections.push_back(g);
             if (dirs->at(i).magnitude()>0.0001)
                 m_ImageGenParameters.numGradients++;
         }
     }
     else if (m_SelectedImage.IsNotNull())   // use geometry of selected image
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImage->GetData());
         itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
         CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
 
         m_ImageGenParameters.imageRegion = itkImg->GetLargestPossibleRegion();
         m_ImageGenParameters.imageSpacing = itkImg->GetSpacing();
         m_ImageGenParameters.imageOrigin = itkImg->GetOrigin();
         m_ImageGenParameters.imageDirection = itkImg->GetDirection();
 
         m_ImageGenParameters.numGradients = m_Controls->m_NumGradientsBox->value();
         m_ImageGenParameters.gradientDirections = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());
         m_ImageGenParameters.b_value = m_Controls->m_BvalueBox->value();
     }
     else    // use GUI parameters
     {
         m_ImageGenParameters.imageRegion.SetSize(0, m_Controls->m_SizeX->value());
         m_ImageGenParameters.imageRegion.SetSize(1, m_Controls->m_SizeY->value());
         m_ImageGenParameters.imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
         m_ImageGenParameters.imageSpacing[0] = m_Controls->m_SpacingX->value();
         m_ImageGenParameters.imageSpacing[1] = m_Controls->m_SpacingY->value();
         m_ImageGenParameters.imageSpacing[2] = m_Controls->m_SpacingZ->value();
         m_ImageGenParameters.imageOrigin[0] = m_ImageGenParameters.imageSpacing[0]/2;
         m_ImageGenParameters.imageOrigin[1] = m_ImageGenParameters.imageSpacing[1]/2;
         m_ImageGenParameters.imageOrigin[2] = m_ImageGenParameters.imageSpacing[2]/2;
         m_ImageGenParameters.imageDirection.SetIdentity();
 
         m_ImageGenParameters.numGradients = m_Controls->m_NumGradientsBox->value();
         m_ImageGenParameters.gradientDirections = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());;
         m_ImageGenParameters.b_value = m_Controls->m_BvalueBox->value();
     }
 
     // signal relaxation
     m_ImageGenParameters.doSimulateRelaxation = m_Controls->m_RelaxationBox->isChecked();
     if (m_ImageGenParameters.doSimulateRelaxation)
         m_ImageGenParameters.artifactModelString += "_RELAX";
 
     // N/2 ghosts
     if (m_Controls->m_AddGhosts->isChecked())
     {
         m_ImageGenParameters.artifactModelString += "_GHOST";
         m_ImageGenParameters.kspaceLineOffset = m_Controls->m_kOffsetBox->value();
     }
     else
         m_ImageGenParameters.kspaceLineOffset = 0;
 
     m_ImageGenParameters.tLine = m_Controls->m_LineReadoutTimeBox->value();
     m_ImageGenParameters.tInhom = m_Controls->m_T2starBox->value();
     m_ImageGenParameters.tEcho = m_Controls->m_TEbox->value();
     m_ImageGenParameters.repetitions = m_Controls->m_RepetitionsBox->value();
     m_ImageGenParameters.doDisablePartialVolume = m_Controls->m_EnforcePureFiberVoxelsBox->isChecked();
     m_ImageGenParameters.interpolationShrink = m_Controls->m_InterpolationShrink->value();
     m_ImageGenParameters.axonRadius = m_Controls->m_FiberRadius->value();
     m_ImageGenParameters.signalScale = m_Controls->m_SignalScaleBox->value();
 
     // adjust echo time if needed
     if ( m_ImageGenParameters.tEcho < m_ImageGenParameters.imageRegion.GetSize(1)*m_ImageGenParameters.tLine )
     {
         this->m_Controls->m_TEbox->setValue( m_ImageGenParameters.imageRegion.GetSize(1)*m_ImageGenParameters.tLine );
         m_ImageGenParameters.tEcho = m_Controls->m_TEbox->value();
         QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(m_ImageGenParameters.tEcho)+" ms");
     }
 
     // check tissue mask
     if (m_TissueMask.IsNotNull())
     {
         m_ImageGenParameters.tissueMaskImage = ItkUcharImgType::New();
         mitk::CastToItkImage<ItkUcharImgType>(m_TissueMask, m_ImageGenParameters.tissueMaskImage);
     }
 
     // rician noise
     if (m_Controls->m_AddNoise->isChecked())
     {
         double noiseVariance = m_Controls->m_NoiseLevel->value();
         m_ImageGenParameters.ricianNoiseModel.SetNoiseVariance(noiseVariance);
         m_ImageGenParameters.artifactModelString += "_NOISE";
         m_ImageGenParameters.artifactModelString += QString::number(noiseVariance);
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
     }
     else
         m_ImageGenParameters.ricianNoiseModel.SetNoiseVariance(0);
 
     // gibbs ringing
     m_ImageGenParameters.upsampling = 1;
     if (m_Controls->m_AddGibbsRinging->isChecked())
     {
         m_ImageGenParameters.artifactModelString += "_RINGING";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Ringing-Upsampling", DoubleProperty::New(m_Controls->m_ImageUpsamplingBox->value()));
         m_ImageGenParameters.upsampling = m_Controls->m_ImageUpsamplingBox->value();
     }
 
     // adjusting line readout time to the adapted image size needed for the DFT
     int y = m_ImageGenParameters.imageRegion.GetSize(1);
     if ( y%2 == 1 )
         y += 1;
     if ( y>m_ImageGenParameters.imageRegion.GetSize(1) )
         m_ImageGenParameters.tLine *= (double)m_ImageGenParameters.imageRegion.GetSize(1)/y;
 
     // add distortions
     if (m_Controls->m_AddDistortions->isChecked() && m_Controls->m_FrequencyMapBox->GetSelectedNode().IsNotNull())
     {
         mitk::DataNode::Pointer fMapNode = m_Controls->m_FrequencyMapBox->GetSelectedNode();
         mitk::Image* img = dynamic_cast<mitk::Image*>(fMapNode->GetData());
         ItkDoubleImgType::Pointer itkImg = ItkDoubleImgType::New();
         CastToItkImage< ItkDoubleImgType >(img, itkImg);
 
         if (m_ImageGenParameters.imageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
                 m_ImageGenParameters.imageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
                 m_ImageGenParameters.imageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
         {
             m_ImageGenParameters.frequencyMap = itkImg;
             m_ImageGenParameters.artifactModelString += "_DISTORTED";
         }
     }
 
     m_ImageGenParameters.doSimulateEddyCurrents = m_Controls->m_AddEddy->isChecked();
     m_ImageGenParameters.eddyStrength = 0;
     if (m_Controls->m_AddEddy->isChecked())
     {
         m_ImageGenParameters.eddyStrength = m_Controls->m_EddyGradientStrength->value();
         m_ImageGenParameters.artifactModelString += "_EDDY";
     }
 
     // signal models
     m_ImageGenParameters.comp3Weight = 1;
     m_ImageGenParameters.comp4Weight = 0;
     if (m_Controls->m_Compartment4Box->currentIndex()>0)
     {
         m_ImageGenParameters.comp4Weight = m_Controls->m_Comp4FractionBox->value();
         m_ImageGenParameters.comp3Weight -= m_ImageGenParameters.comp4Weight;
     }
 
     // compartment 1
     switch (m_Controls->m_Compartment1Box->currentIndex())
     {
     case 0:
         m_StickModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_StickModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_StickModel1.SetDiffusivity(m_Controls->m_StickWidget1->GetD());
         m_StickModel1.SetT2(m_Controls->m_StickWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_StickModel1);
         m_ImageGenParameters.signalModelString += "Stick";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_StickModel1.GetT2()) );
         break;
     case 1:
         m_ZeppelinModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_ZeppelinModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_ZeppelinModel1.SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
         m_ZeppelinModel1.SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
         m_ZeppelinModel1.SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
         m_ZeppelinModel1.SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_ZeppelinModel1);
         m_ImageGenParameters.signalModelString += "Zeppelin";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_ZeppelinModel1.GetT2()) );
         break;
     case 2:
         m_TensorModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_TensorModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_TensorModel1.SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
         m_TensorModel1.SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
         m_TensorModel1.SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
         m_TensorModel1.SetT2(m_Controls->m_TensorWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_TensorModel1);
         m_ImageGenParameters.signalModelString += "Tensor";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_ZeppelinModel1.GetT2()) );
         break;
     }
 
     // compartment 2
     switch (m_Controls->m_Compartment2Box->currentIndex())
     {
     case 0:
         break;
     case 1:
         m_StickModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_StickModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_StickModel2.SetDiffusivity(m_Controls->m_StickWidget2->GetD());
         m_StickModel2.SetT2(m_Controls->m_StickWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_StickModel2);
         m_ImageGenParameters.signalModelString += "Stick";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_StickModel2.GetT2()) );
         break;
     case 2:
         m_ZeppelinModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_ZeppelinModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_ZeppelinModel2.SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
         m_ZeppelinModel2.SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
         m_ZeppelinModel2.SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
         m_ZeppelinModel2.SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_ZeppelinModel2);
         m_ImageGenParameters.signalModelString += "Zeppelin";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_ZeppelinModel2.GetT2()) );
         break;
     case 3:
         m_TensorModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_TensorModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_TensorModel2.SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
         m_TensorModel2.SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
         m_TensorModel2.SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
         m_TensorModel2.SetT2(m_Controls->m_TensorWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_TensorModel2);
         m_ImageGenParameters.signalModelString += "Tensor";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_ZeppelinModel2.GetT2()) );
         break;
     }
 
     // compartment 3
     switch (m_Controls->m_Compartment3Box->currentIndex())
     {
     case 0:
         m_BallModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_BallModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_BallModel1.SetDiffusivity(m_Controls->m_BallWidget1->GetD());
         m_BallModel1.SetT2(m_Controls->m_BallWidget1->GetT2());
         m_BallModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_BallModel1);
         m_ImageGenParameters.signalModelString += "Ball";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_BallModel1.GetT2()) );
         break;
     case 1:
         m_AstrosticksModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_AstrosticksModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_AstrosticksModel1.SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
         m_AstrosticksModel1.SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
         m_AstrosticksModel1.SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
         m_AstrosticksModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_AstrosticksModel1);
         m_ImageGenParameters.signalModelString += "Astrosticks";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_AstrosticksModel1.GetT2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
         break;
     case 2:
         m_DotModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_DotModel1.SetT2(m_Controls->m_DotWidget1->GetT2());
         m_DotModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_DotModel1);
         m_ImageGenParameters.signalModelString += "Dot";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_DotModel1.GetT2()) );
         break;
     }
 
     // compartment 4
     switch (m_Controls->m_Compartment4Box->currentIndex())
     {
     case 0:
         break;
     case 1:
         m_BallModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_BallModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_BallModel2.SetDiffusivity(m_Controls->m_BallWidget2->GetD());
         m_BallModel2.SetT2(m_Controls->m_BallWidget2->GetT2());
         m_BallModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_BallModel2);
         m_ImageGenParameters.signalModelString += "Ball";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_BallModel2.GetT2()) );
         break;
     case 2:
         m_AstrosticksModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_AstrosticksModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_AstrosticksModel2.SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
         m_AstrosticksModel2.SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
         m_AstrosticksModel2.SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
         m_AstrosticksModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_AstrosticksModel2);
         m_ImageGenParameters.signalModelString += "Astrosticks";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_AstrosticksModel2.GetT2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
         break;
     case 3:
         m_DotModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_DotModel2.SetT2(m_Controls->m_DotWidget2->GetT2());
         m_DotModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_DotModel2);
         m_ImageGenParameters.signalModelString += "Dot";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_DotModel2.GetT2()) );
         break;
     }
 
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.InterpolationShrink", IntProperty::New(m_ImageGenParameters.interpolationShrink));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(m_ImageGenParameters.signalScale));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(m_ImageGenParameters.axonRadius));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Tinhom", IntProperty::New(m_ImageGenParameters.tInhom));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Repetitions", IntProperty::New(m_ImageGenParameters.repetitions));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(m_ImageGenParameters.b_value));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Model", StringProperty::New(m_ImageGenParameters.signalModelString.toStdString()));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.PureFiberVoxels", BoolProperty::New(m_ImageGenParameters.doDisablePartialVolume));
     m_ImageGenParameters.resultNode->AddProperty("binary", BoolProperty::New(false));
 }
 
 void QmitkFiberfoxView::SaveParameters()
 {
     UpdateImageParameters();
 
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 QDir::currentPath()+"/param.ffp",
                 tr("Fiberfox Parameters (*.ffp)") );
 
     if(filename.isEmpty() || filename.isNull())
         return;
     if(!filename.endsWith(".ffp"))
         filename += ".ffp";
 
     boost::property_tree::ptree parameters;
 
     // fiber generation parameters
     parameters.put("fiberfox.fibers.realtime", m_Controls->m_RealTimeFibers->isChecked());
     parameters.put("fiberfox.fibers.showadvanced", m_Controls->m_AdvancedOptionsBox->isChecked());
     parameters.put("fiberfox.fibers.distribution", m_Controls->m_DistributionBox->currentIndex());
     parameters.put("fiberfox.fibers.variance", m_Controls->m_VarianceBox->value());
     parameters.put("fiberfox.fibers.density", m_Controls->m_FiberDensityBox->value());
     parameters.put("fiberfox.fibers.spline.sampling", m_Controls->m_FiberSamplingBox->value());
     parameters.put("fiberfox.fibers.spline.tension", m_Controls->m_TensionBox->value());
     parameters.put("fiberfox.fibers.spline.continuity", m_Controls->m_ContinuityBox->value());
     parameters.put("fiberfox.fibers.spline.bias", m_Controls->m_BiasBox->value());
     parameters.put("fiberfox.fibers.constantradius", m_Controls->m_ConstantRadiusBox->isChecked());
     parameters.put("fiberfox.fibers.rotation.x", m_Controls->m_XrotBox->value());
     parameters.put("fiberfox.fibers.rotation.y", m_Controls->m_YrotBox->value());
     parameters.put("fiberfox.fibers.rotation.z", m_Controls->m_ZrotBox->value());
     parameters.put("fiberfox.fibers.translation.x", m_Controls->m_XtransBox->value());
     parameters.put("fiberfox.fibers.translation.y", m_Controls->m_YtransBox->value());
     parameters.put("fiberfox.fibers.translation.z", m_Controls->m_ZtransBox->value());
     parameters.put("fiberfox.fibers.scale.x", m_Controls->m_XscaleBox->value());
     parameters.put("fiberfox.fibers.scale.y", m_Controls->m_YscaleBox->value());
     parameters.put("fiberfox.fibers.scale.z", m_Controls->m_ZscaleBox->value());
     parameters.put("fiberfox.fibers.includeFiducials", m_Controls->m_IncludeFiducials->isChecked());
     parameters.put("fiberfox.fibers.includeFiducials", m_Controls->m_IncludeFiducials->isChecked());
 
     // image generation parameters
     parameters.put("fiberfox.image.basic.size.x", m_ImageGenParameters.imageRegion.GetSize(0));
     parameters.put("fiberfox.image.basic.size.y", m_ImageGenParameters.imageRegion.GetSize(1));
     parameters.put("fiberfox.image.basic.size.z", m_ImageGenParameters.imageRegion.GetSize(2));
     parameters.put("fiberfox.image.basic.spacing.x", m_ImageGenParameters.imageSpacing[0]);
     parameters.put("fiberfox.image.basic.spacing.y", m_ImageGenParameters.imageSpacing[1]);
     parameters.put("fiberfox.image.basic.spacing.z", m_ImageGenParameters.imageSpacing[2]);
     parameters.put("fiberfox.image.basic.numgradients", m_ImageGenParameters.numGradients);
     parameters.put("fiberfox.image.basic.bvalue", m_ImageGenParameters.b_value);
     parameters.put("fiberfox.image.showadvanced", m_Controls->m_AdvancedOptionsBox_2->isChecked());
     parameters.put("fiberfox.image.repetitions", m_ImageGenParameters.repetitions);
     parameters.put("fiberfox.image.signalScale", m_ImageGenParameters.signalScale);
     parameters.put("fiberfox.image.tEcho", m_ImageGenParameters.tEcho);
     parameters.put("fiberfox.image.tLine", m_Controls->m_LineReadoutTimeBox->value());
     parameters.put("fiberfox.image.tInhom", m_ImageGenParameters.tInhom);
     parameters.put("fiberfox.image.axonRadius", m_ImageGenParameters.axonRadius);
     parameters.put("fiberfox.image.interpolationShrink", m_ImageGenParameters.interpolationShrink);
     parameters.put("fiberfox.image.doSimulateRelaxation", m_ImageGenParameters.doSimulateRelaxation);
     parameters.put("fiberfox.image.doDisablePartialVolume", m_ImageGenParameters.doDisablePartialVolume);
     parameters.put("fiberfox.image.outputvolumefractions", m_Controls->m_VolumeFractionsBox->isChecked());
 
     parameters.put("fiberfox.image.artifacts.addnoise", m_Controls->m_AddNoise->isChecked());
     parameters.put("fiberfox.image.artifacts.noisevariance", m_Controls->m_NoiseLevel->value());
     parameters.put("fiberfox.image.artifacts.addghost", m_Controls->m_AddGhosts->isChecked());
     parameters.put("fiberfox.image.artifacts.kspaceLineOffset", m_Controls->m_kOffsetBox->value());
     parameters.put("fiberfox.image.artifacts.distortions", m_Controls->m_AddDistortions->isChecked());
     parameters.put("fiberfox.image.artifacts.addeddy", m_Controls->m_AddEddy->isChecked());
     parameters.put("fiberfox.image.artifacts.eddyStrength", m_Controls->m_EddyGradientStrength->value());
     parameters.put("fiberfox.image.artifacts.addringing", m_Controls->m_AddGibbsRinging->isChecked());
     parameters.put("fiberfox.image.artifacts.ringingupsampling", m_Controls->m_ImageUpsamplingBox->value());
 
     parameters.put("fiberfox.image.compartment1.index", m_Controls->m_Compartment1Box->currentIndex());
     parameters.put("fiberfox.image.compartment2.index", m_Controls->m_Compartment2Box->currentIndex());
     parameters.put("fiberfox.image.compartment3.index", m_Controls->m_Compartment3Box->currentIndex());
     parameters.put("fiberfox.image.compartment4.index", m_Controls->m_Compartment4Box->currentIndex());
 
     parameters.put("fiberfox.image.compartment1.stick.d", m_Controls->m_StickWidget1->GetD());
     parameters.put("fiberfox.image.compartment1.stick.t2", m_Controls->m_StickWidget1->GetT2());
     parameters.put("fiberfox.image.compartment1.zeppelin.d1", m_Controls->m_ZeppelinWidget1->GetD1());
     parameters.put("fiberfox.image.compartment1.zeppelin.d2", m_Controls->m_ZeppelinWidget1->GetD2());
     parameters.put("fiberfox.image.compartment1.zeppelin.t2", m_Controls->m_ZeppelinWidget1->GetT2());
     parameters.put("fiberfox.image.compartment1.tensor.d1", m_Controls->m_TensorWidget1->GetD1());
     parameters.put("fiberfox.image.compartment1.tensor.d2", m_Controls->m_TensorWidget1->GetD2());
     parameters.put("fiberfox.image.compartment1.tensor.d3", m_Controls->m_TensorWidget1->GetD3());
     parameters.put("fiberfox.image.compartment1.tensor.t2", m_Controls->m_TensorWidget1->GetT2());
 
     parameters.put("fiberfox.image.compartment2.stick.d", m_Controls->m_StickWidget2->GetD());
     parameters.put("fiberfox.image.compartment2.stick.t2", m_Controls->m_StickWidget2->GetT2());
     parameters.put("fiberfox.image.compartment2.zeppelin.d1", m_Controls->m_ZeppelinWidget2->GetD1());
     parameters.put("fiberfox.image.compartment2.zeppelin.d2", m_Controls->m_ZeppelinWidget2->GetD2());
     parameters.put("fiberfox.image.compartment2.zeppelin.t2", m_Controls->m_ZeppelinWidget2->GetT2());
     parameters.put("fiberfox.image.compartment2.tensor.d1", m_Controls->m_TensorWidget2->GetD1());
     parameters.put("fiberfox.image.compartment2.tensor.d2", m_Controls->m_TensorWidget2->GetD2());
     parameters.put("fiberfox.image.compartment2.tensor.d3", m_Controls->m_TensorWidget2->GetD3());
     parameters.put("fiberfox.image.compartment2.tensor.t2", m_Controls->m_TensorWidget2->GetT2());
 
     parameters.put("fiberfox.image.compartment3.ball.d", m_Controls->m_BallWidget1->GetD());
     parameters.put("fiberfox.image.compartment3.ball.t2", m_Controls->m_BallWidget1->GetT2());
     parameters.put("fiberfox.image.compartment3.astrosticks.d", m_Controls->m_AstrosticksWidget1->GetD());
     parameters.put("fiberfox.image.compartment3.astrosticks.t2", m_Controls->m_AstrosticksWidget1->GetT2());
     parameters.put("fiberfox.image.compartment3.astrosticks.randomize", m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
     parameters.put("fiberfox.image.compartment3.dot.t2", m_Controls->m_DotWidget1->GetT2());
 
     parameters.put("fiberfox.image.compartment4.ball.d", m_Controls->m_BallWidget2->GetD());
     parameters.put("fiberfox.image.compartment4.ball.t2", m_Controls->m_BallWidget2->GetT2());
     parameters.put("fiberfox.image.compartment4.astrosticks.d", m_Controls->m_AstrosticksWidget2->GetD());
     parameters.put("fiberfox.image.compartment4.astrosticks.t2", m_Controls->m_AstrosticksWidget2->GetT2());
     parameters.put("fiberfox.image.compartment4.astrosticks.randomize", m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
     parameters.put("fiberfox.image.compartment4.dot.t2", m_Controls->m_DotWidget2->GetT2());
 
     parameters.put("fiberfox.image.compartment4.weight", m_Controls->m_Comp4FractionBox->value());
 
     boost::property_tree::xml_parser::write_xml(filename.toStdString(), parameters);
 }
 
 void QmitkFiberfoxView::LoadParameters()
 {
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QDir::currentPath(), tr("Fiberfox Parameters (*.ffp)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     boost::property_tree::ptree parameters;
     boost::property_tree::xml_parser::read_xml(filename.toStdString(), parameters);
 
     BOOST_FOREACH( boost::property_tree::ptree::value_type const& v1, parameters.get_child("fiberfox") )
     {
         if( v1.first == "fibers" )
         {
             m_Controls->m_RealTimeFibers->setChecked(v1.second.get<bool>("realtime"));
             m_Controls->m_AdvancedOptionsBox->setChecked(v1.second.get<bool>("showadvanced"));
             m_Controls->m_DistributionBox->setCurrentIndex(v1.second.get<int>("distribution"));
             m_Controls->m_VarianceBox->setValue(v1.second.get<double>("variance"));
             m_Controls->m_FiberDensityBox->setValue(v1.second.get<int>("density"));
             m_Controls->m_IncludeFiducials->setChecked(v1.second.get<bool>("includeFiducials"));
             m_Controls->m_ConstantRadiusBox->setChecked(v1.second.get<bool>("constantradius"));
 
             BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second )
             {
                 if( v2.first == "spline" )
                 {
                     m_Controls->m_FiberSamplingBox->setValue(v2.second.get<double>("sampling"));
                     m_Controls->m_TensionBox->setValue(v2.second.get<double>("tension"));
                     m_Controls->m_ContinuityBox->setValue(v2.second.get<double>("continuity"));
                     m_Controls->m_BiasBox->setValue(v2.second.get<double>("bias"));
                 }
                 if( v2.first == "rotation" )
                 {
                     m_Controls->m_XrotBox->setValue(v2.second.get<double>("x"));
                     m_Controls->m_YrotBox->setValue(v2.second.get<double>("y"));
                     m_Controls->m_ZrotBox->setValue(v2.second.get<double>("z"));
                 }
                 if( v2.first == "translation" )
                 {
                     m_Controls->m_XtransBox->setValue(v2.second.get<double>("x"));
                     m_Controls->m_YtransBox->setValue(v2.second.get<double>("y"));
                     m_Controls->m_ZtransBox->setValue(v2.second.get<double>("z"));
                 }
                 if( v2.first == "scale" )
                 {
                     m_Controls->m_XscaleBox->setValue(v2.second.get<double>("x"));
                     m_Controls->m_YscaleBox->setValue(v2.second.get<double>("y"));
                     m_Controls->m_ZscaleBox->setValue(v2.second.get<double>("z"));
                 }
             }
         }
         if( v1.first == "image" )
         {
             m_Controls->m_SizeX->setValue(v1.second.get<int>("basic.size.x"));
             m_Controls->m_SizeY->setValue(v1.second.get<int>("basic.size.y"));
             m_Controls->m_SizeZ->setValue(v1.second.get<int>("basic.size.z"));
             m_Controls->m_SpacingX->setValue(v1.second.get<double>("basic.spacing.x"));
             m_Controls->m_SpacingY->setValue(v1.second.get<double>("basic.spacing.y"));
             m_Controls->m_SpacingZ->setValue(v1.second.get<double>("basic.spacing.z"));
             m_Controls->m_NumGradientsBox->setValue(v1.second.get<int>("basic.numgradients"));
             m_Controls->m_BvalueBox->setValue(v1.second.get<int>("basic.bvalue"));
             m_Controls->m_AdvancedOptionsBox_2->setChecked(v1.second.get<bool>("showadvanced"));
             m_Controls->m_RepetitionsBox->setValue(v1.second.get<int>("repetitions"));
             m_Controls->m_SignalScaleBox->setValue(v1.second.get<int>("signalScale"));
             m_Controls->m_TEbox->setValue(v1.second.get<double>("tEcho"));
             m_Controls->m_LineReadoutTimeBox->setValue(v1.second.get<double>("tLine"));
             m_Controls->m_T2starBox->setValue(v1.second.get<double>("tInhom"));
             m_Controls->m_FiberRadius->setValue(v1.second.get<double>("axonRadius"));
             m_Controls->m_InterpolationShrink->setValue(v1.second.get<int>("interpolationShrink"));
             m_Controls->m_RelaxationBox->setChecked(v1.second.get<bool>("doSimulateRelaxation"));
             m_Controls->m_EnforcePureFiberVoxelsBox->setChecked(v1.second.get<bool>("doDisablePartialVolume"));
             m_Controls->m_VolumeFractionsBox->setChecked(v1.second.get<bool>("outputvolumefractions"));
 
             m_Controls->m_AddNoise->setChecked(v1.second.get<bool>("artifacts.addnoise"));
             m_Controls->m_NoiseLevel->setValue(v1.second.get<double>("artifacts.noisevariance"));
             m_Controls->m_AddGhosts->setChecked(v1.second.get<bool>("artifacts.addghost"));
             m_Controls->m_kOffsetBox->setValue(v1.second.get<double>("artifacts.kspaceLineOffset"));
             m_Controls->m_AddDistortions->setChecked(v1.second.get<bool>("artifacts.distortions"));
 
             m_Controls->m_AddEddy->setChecked(v1.second.get<bool>("artifacts.addeddy"));
             m_Controls->m_EddyGradientStrength->setValue(v1.second.get<double>("artifacts.eddyStrength"));
             m_Controls->m_AddGibbsRinging->setChecked(v1.second.get<bool>("artifacts.addringing"));
             m_Controls->m_ImageUpsamplingBox->setValue(v1.second.get<double>("artifacts.ringingupsampling"));
 
             m_Controls->m_Compartment1Box->setCurrentIndex(v1.second.get<int>("compartment1.index"));
             m_Controls->m_Compartment2Box->setCurrentIndex(v1.second.get<int>("compartment2.index"));
             m_Controls->m_Compartment3Box->setCurrentIndex(v1.second.get<int>("compartment3.index"));
             m_Controls->m_Compartment4Box->setCurrentIndex(v1.second.get<int>("compartment4.index"));
 
 
             m_Controls->m_StickWidget1->SetD(v1.second.get<double>("compartment1.stick.d"));
             m_Controls->m_StickWidget1->SetT2(v1.second.get<double>("compartment1.stick.t2"));
             m_Controls->m_ZeppelinWidget1->SetD1(v1.second.get<double>("compartment1.zeppelin.d1"));
             m_Controls->m_ZeppelinWidget1->SetD2(v1.second.get<double>("compartment1.zeppelin.d2"));
             m_Controls->m_ZeppelinWidget1->SetT2(v1.second.get<double>("compartment1.zeppelin.t2"));
             m_Controls->m_TensorWidget1->SetD1(v1.second.get<double>("compartment1.tensor.d1"));
             m_Controls->m_TensorWidget1->SetD2(v1.second.get<double>("compartment1.tensor.d2"));
             m_Controls->m_TensorWidget1->SetD3(v1.second.get<double>("compartment1.tensor.d3"));
             m_Controls->m_TensorWidget1->SetT2(v1.second.get<double>("compartment1.tensor.t2"));
 
             m_Controls->m_StickWidget2->SetD(v1.second.get<double>("compartment2.stick.d"));
             m_Controls->m_StickWidget2->SetT2(v1.second.get<double>("compartment2.stick.t2"));
             m_Controls->m_ZeppelinWidget2->SetD1(v1.second.get<double>("compartment2.zeppelin.d1"));
             m_Controls->m_ZeppelinWidget2->SetD2(v1.second.get<double>("compartment2.zeppelin.d2"));
             m_Controls->m_ZeppelinWidget2->SetT2(v1.second.get<double>("compartment2.zeppelin.t2"));
             m_Controls->m_TensorWidget2->SetD1(v1.second.get<double>("compartment2.tensor.d1"));
             m_Controls->m_TensorWidget2->SetD2(v1.second.get<double>("compartment2.tensor.d2"));
             m_Controls->m_TensorWidget2->SetD3(v1.second.get<double>("compartment2.tensor.d3"));
             m_Controls->m_TensorWidget2->SetT2(v1.second.get<double>("compartment2.tensor.t2"));
 
             m_Controls->m_BallWidget1->SetD(v1.second.get<double>("compartment3.ball.d"));
             m_Controls->m_BallWidget1->SetT2(v1.second.get<double>("compartment3.ball.t2"));
             m_Controls->m_AstrosticksWidget1->SetD(v1.second.get<double>("compartment3.astrosticks.d"));
             m_Controls->m_AstrosticksWidget1->SetT2(v1.second.get<double>("compartment3.astrosticks.t2"));
             m_Controls->m_AstrosticksWidget1->SetRandomizeSticks(v1.second.get<bool>("compartment3.astrosticks.randomize"));
             m_Controls->m_DotWidget1->SetT2(v1.second.get<double>("compartment3.dot.t2"));
 
             m_Controls->m_BallWidget2->SetD(v1.second.get<double>("compartment4.ball.d"));
             m_Controls->m_BallWidget2->SetT2(v1.second.get<double>("compartment4.ball.t2"));
             m_Controls->m_AstrosticksWidget2->SetD(v1.second.get<double>("compartment4.astrosticks.d"));
             m_Controls->m_AstrosticksWidget2->SetT2(v1.second.get<double>("compartment4.astrosticks.t2"));
             m_Controls->m_AstrosticksWidget2->SetRandomizeSticks(v1.second.get<bool>("compartment4.astrosticks.randomize"));
             m_Controls->m_DotWidget2->SetT2(v1.second.get<double>("compartment4.dot.t2"));
 
             m_Controls->m_Comp4FractionBox->setValue(v1.second.get<double>("compartment4.weight"));
         }
     }
     UpdateImageParameters();
 }
 
 void QmitkFiberfoxView::ShowAdvancedOptions(int state)
 {
     if (state)
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedOptionsBox->setChecked(true);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(true);
     }
     else
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedOptionsBox->setChecked(false);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(false);
     }
 }
 
 void QmitkFiberfoxView::Comp1ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget1->setVisible(false);
     m_Controls->m_ZeppelinWidget1->setVisible(false);
     m_Controls->m_TensorWidget1->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_StickWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_ZeppelinWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_TensorWidget1->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp2ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget2->setVisible(false);
     m_Controls->m_ZeppelinWidget2->setVisible(false);
     m_Controls->m_TensorWidget2->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_StickWidget2->setVisible(true);
         break;
     case 2:
         m_Controls->m_ZeppelinWidget2->setVisible(true);
         break;
     case 3:
         m_Controls->m_TensorWidget2->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp3ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget1->setVisible(false);
     m_Controls->m_AstrosticksWidget1->setVisible(false);
     m_Controls->m_DotWidget1->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_BallWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_AstrosticksWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_DotWidget1->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp4ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget2->setVisible(false);
     m_Controls->m_AstrosticksWidget2->setVisible(false);
     m_Controls->m_DotWidget2->setVisible(false);
     m_Controls->m_Comp4FractionFrame->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_BallWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 2:
         m_Controls->m_AstrosticksWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 3:
         m_Controls->m_DotWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::OnConstantRadius(int value)
 {
     if (value>0 && m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnAddEddy(int value)
 {
     if (value>0)
         m_Controls->m_EddyFrame->setVisible(true);
     else
         m_Controls->m_EddyFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddDistortions(int value)
 {
     if (value>0)
         m_Controls->m_DistortionsFrame->setVisible(true);
     else
         m_Controls->m_DistortionsFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddGhosts(int value)
 {
     if (value>0)
         m_Controls->m_GhostFrame->setVisible(true);
     else
         m_Controls->m_GhostFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddNoise(int value)
 {
     if (value>0)
         m_Controls->m_NoiseFrame->setVisible(true);
     else
         m_Controls->m_NoiseFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddGibbsRinging(int value)
 {
     if (value>0)
         m_Controls->m_GibbsRingingFrame->setVisible(true);
     else
         m_Controls->m_GibbsRingingFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnDistributionChanged(int value)
 {
     if (value==1)
         m_Controls->m_VarianceBox->setVisible(true);
     else
         m_Controls->m_VarianceBox->setVisible(false);
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnVarianceChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberDensityChanged(int value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberSamplingChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnTensionChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnContinuityChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnBiasChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::AlignOnGrid()
 {
     for (int i=0; i<m_SelectedFiducials.size(); i++)
     {
         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
         mitk::DataStorage::SetOfObjects::ConstPointer parentFibs = GetDataStorage()->GetSources(m_SelectedFiducials.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parentFibs->begin(); it != parentFibs->end(); ++it )
         {
             mitk::DataNode::Pointer pFibNode = *it;
             if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pFibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(pFibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer pImgNode = *it2;
                     if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
                     {
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(pImgNode->GetData());
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
 
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
 
                         break;
                     }
                 }
                 break;
             }
         }
     }
 
     for( int i=0; i<m_SelectedBundles2.size(); i++ )
     {
         mitk::DataNode::Pointer fibNode = m_SelectedBundles2.at(i);
 
         mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(fibNode);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = sources->begin(); it != sources->end(); ++it )
         {
             mitk::DataNode::Pointer imgNode = *it;
             if ( imgNode.IsNotNull() && dynamic_cast<mitk::Image*>(imgNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(imgNode->GetData());
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
 
                 break;
             }
         }
     }
 
     for( int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImages.at(i)->GetData());
 
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
             if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations2 = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations2->begin(); it2 != derivations2->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
             }
         }
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFlipButton()
 {
     if (m_SelectedFiducial.IsNull())
         return;
 
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(m_SelectedFiducial.GetPointer());
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
         data.m_Flipped += 1;
         data.m_Flipped %= 2;
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 QmitkFiberfoxView::GradientListType QmitkFiberfoxView::GenerateHalfShell(int NPoints)
 {
     NPoints *= 2;
     GradientListType pointshell;
 
     int numB0 = NPoints/20;
     if (numB0==0)
         numB0=1;
     GradientType g;
     g.Fill(0.0);
     for (int i=0; i<numB0; i++)
         pointshell.push_back(g);
 
     if (NPoints==0)
         return pointshell;
 
     vnl_vector<double> theta; theta.set_size(NPoints);
     vnl_vector<double> phi; phi.set_size(NPoints);
     double C = sqrt(4*M_PI);
     phi(0) = 0.0;
     phi(NPoints-1) = 0.0;
     for(int i=0; i<NPoints; i++)
     {
         theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
         if( i>0 && i<NPoints-1)
         {
             phi(i) = (phi(i-1) + C /
                       sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
             // % (2*DIST_POINTSHELL_PI);
         }
     }
 
     for(int i=0; i<NPoints; i++)
     {
         g[2] = sin(theta(i));
         if (g[2]<0)
             continue;
         g[0] = cos(theta(i)) * cos(phi(i));
         g[1] = cos(theta(i)) * sin(phi(i));
         pointshell.push_back(g);
     }
 
     return pointshell;
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkFiberfoxView::MakeGradientList()
 {
     std::vector<itk::Vector<double,3> > retval;
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
 
     // Add 0 vector for B0
     int numB0 = ndirs/10;
     if (numB0==0)
         numB0=1;
     itk::Vector<double,3> v;
     v.Fill(0.0);
     for (int i=0; i<numB0; i++)
     {
         retval.push_back(v);
     }
 
     for(int i=0; i<ndirs;i++)
     {
         itk::Vector<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval.push_back(v);
     }
 
     return retval;
 }
 
 void QmitkFiberfoxView::OnAddBundle()
 {
     if (m_SelectedImage.IsNull())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImage);
 
     mitk::FiberBundleX::Pointer bundle = mitk::FiberBundleX::New();
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( bundle );
     QString name = QString("Bundle_%1").arg(children->size());
     node->SetName(name.toStdString());
     m_SelectedBundles.push_back(node);
     UpdateGui();
 
     GetDataStorage()->Add(node, m_SelectedImage);
 }
 
 void QmitkFiberfoxView::OnDrawROI()
 {
     if (m_SelectedBundles.empty())
         OnAddBundle();
     if (m_SelectedBundles.empty())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(0));
 
     mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( figure );
 
 
     QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
     for( int i=0; i<nodes.size(); i++)
         nodes.at(i)->SetSelected(false);
 
     m_SelectedFiducial = node;
 
     QString name = QString("Fiducial_%1").arg(children->size());
     node->SetName(name.toStdString());
     node->SetSelected(true);
     GetDataStorage()->Add(node, m_SelectedBundles.at(0));
 
     this->DisableCrosshairNavigation();
 
     mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "PlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( node );
     }
 
     UpdateGui();
 }
 
 bool CompareLayer(mitk::DataNode::Pointer i,mitk::DataNode::Pointer j)
 {
     int li = -1;
     i->GetPropertyValue("layer", li);
     int lj = -1;
     j->GetPropertyValue("layer", lj);
     return li<lj;
 }
 
 void QmitkFiberfoxView::GenerateFibers()
 {
     if (m_SelectedBundles.empty())
     {
         if (m_SelectedFiducial.IsNull())
             return;
 
         mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(m_SelectedFiducial);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             if(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()))
                 m_SelectedBundles.push_back(*it);
 
         if (m_SelectedBundles.empty())
             return;
     }
 
     vector< vector< mitk::PlanarEllipse::Pointer > > fiducials;
     vector< vector< unsigned int > > fliplist;
     for (int i=0; i<m_SelectedBundles.size(); i++)
     {
         mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(i));
         std::vector< mitk::DataNode::Pointer > childVector;
         for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
             childVector.push_back(*it);
         sort(childVector.begin(), childVector.end(), CompareLayer);
 
         vector< mitk::PlanarEllipse::Pointer > fib;
         vector< unsigned int > flip;
         float radius = 1;
         int count = 0;
         for( std::vector< mitk::DataNode::Pointer >::const_iterator it = childVector.begin(); it != childVector.end(); ++it )
         {
             mitk::DataNode::Pointer node = *it;
 
             if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
             {
                 mitk::PlanarEllipse* ellipse = dynamic_cast<mitk::PlanarEllipse*>(node->GetData());
                 if (m_Controls->m_ConstantRadiusBox->isChecked())
                 {
                     ellipse->SetTreatAsCircle(true);
                     mitk::Point2D c = ellipse->GetControlPoint(0);
                     mitk::Point2D p = ellipse->GetControlPoint(1);
                     mitk::Vector2D v = p-c;
                     if (count==0)
                     {
                         radius = v.GetVnlVector().magnitude();
                         ellipse->SetControlPoint(1, p);
                     }
                     else
                     {
                         v.Normalize();
                         v *= radius;
                         ellipse->SetControlPoint(1, c+v);
                     }
                 }
                 fib.push_back(ellipse);
 
                 std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(node.GetPointer());
                 if( it != m_DataNodeToPlanarFigureData.end() )
                 {
                     QmitkPlanarFigureData& data = it->second;
                     flip.push_back(data.m_Flipped);
                 }
                 else
                     flip.push_back(0);
             }
             count++;
         }
         if (fib.size()>1)
         {
             fiducials.push_back(fib);
             fliplist.push_back(flip);
         }
         else if (fib.size()>0)
             m_SelectedBundles.at(i)->SetData( mitk::FiberBundleX::New() );
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
     filter->SetFiducials(fiducials);
     filter->SetFlipList(fliplist);
 
     switch(m_Controls->m_DistributionBox->currentIndex()){
     case 0:
         filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_UNIFORM);
         break;
     case 1:
         filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_GAUSSIAN);
         filter->SetVariance(m_Controls->m_VarianceBox->value());
         break;
     }
 
     filter->SetDensity(m_Controls->m_FiberDensityBox->value());
     filter->SetTension(m_Controls->m_TensionBox->value());
     filter->SetContinuity(m_Controls->m_ContinuityBox->value());
     filter->SetBias(m_Controls->m_BiasBox->value());
     filter->SetFiberSampling(m_Controls->m_FiberSamplingBox->value());
     filter->Update();
     vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
 
     for (int i=0; i<fiberBundles.size(); i++)
     {
         m_SelectedBundles.at(i)->SetData( fiberBundles.at(i) );
         if (fiberBundles.at(i)->GetNumFibers()>50000)
             m_SelectedBundles.at(i)->SetVisibility(false);
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::GenerateImage()
 {
     UpdateImageParameters();
     if (m_SelectedBundles.empty())
     {
         if (m_SelectedDWI.IsNotNull()) // add artifacts to existing diffusion weighted image
         {
             for (int i=0; i<m_SelectedImages.size(); i++)
             {
                 if (!dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedImages.at(i)->GetData()))
                     continue;
 
                 m_SelectedDWI = m_SelectedImages.at(i);
                 UpdateImageParameters();
 
                 mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedImages.at(i)->GetData());
 
                 mitk::RicianNoiseModel<short> noiseModel;
                 noiseModel.SetNoiseVariance(m_ImageGenParameters.ricianNoiseModel.GetNoiseVariance());
 
                 itk::AddArtifactsToDwiImageFilter< short >::Pointer filter = itk::AddArtifactsToDwiImageFilter< short >::New();
                 filter->SetInput(diffImg->GetVectorImage());
                 filter->SettLine(m_ImageGenParameters.tLine);
                 filter->SetkOffset(m_ImageGenParameters.kspaceLineOffset);
                 filter->SetNoiseModel(&noiseModel);
                 filter->SetGradientList(m_ImageGenParameters.gradientDirections);
                 filter->SetTE(m_ImageGenParameters.tEcho);
                 filter->SetSimulateEddyCurrents(m_ImageGenParameters.doSimulateEddyCurrents);
                 filter->SetEddyGradientStrength(m_ImageGenParameters.eddyStrength);
                 filter->SetUpsampling(m_ImageGenParameters.upsampling);
                 filter->SetFrequencyMap(m_ImageGenParameters.frequencyMap);
                 filter->Update();
 
                 mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
                 image->SetVectorImage( filter->GetOutput() );
                 image->SetB_Value(diffImg->GetB_Value());
                 image->SetDirections(diffImg->GetDirections());
                 image->InitializeFromVectorImage();
                 m_ImageGenParameters.resultNode->SetData( image );
                 m_ImageGenParameters.resultNode->SetName(m_SelectedImages.at(i)->GetName()+m_ImageGenParameters.artifactModelString.toStdString());
                 GetDataStorage()->Add(m_ImageGenParameters.resultNode);
             }
             m_SelectedDWI = m_SelectedImages.front();
             return;
         }
 
         mitk::Image::Pointer image = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(
                     m_Controls->m_SizeX->value(),
                     m_Controls->m_SizeY->value(),
                     m_Controls->m_SizeZ->value(),
                     m_Controls->m_SpacingX->value(),
                     m_Controls->m_SpacingY->value(),
                     m_Controls->m_SpacingZ->value());
 
         mitk::Geometry3D* geom = image->GetGeometry();
         geom->SetOrigin(m_ImageGenParameters.imageOrigin);
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData( image );
         node->SetName("Dummy");
         unsigned int window = m_Controls->m_SizeX->value()*m_Controls->m_SizeY->value()*m_Controls->m_SizeZ->value();
         unsigned int level = window/2;
         mitk::LevelWindow lw; lw.SetLevelWindow(level, window);
         node->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
         GetDataStorage()->Add(node);
         m_SelectedImage = node;
 
         mitk::BaseData::Pointer basedata = node->GetData();
         if (basedata.IsNotNull())
         {
             mitk::RenderingManager::GetInstance()->InitializeViews( basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
         UpdateGui();
 
         return;
     }
 
     for (int i=0; i<m_SelectedBundles.size(); i++)
     {
         mitk::FiberBundleX::Pointer fiberBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedBundles.at(i)->GetData());
         if (fiberBundle->GetNumFibers()<=0)
             continue;
 
         itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
 
         tractsToDwiFilter->SetSimulateEddyCurrents(m_ImageGenParameters.doSimulateEddyCurrents);
         tractsToDwiFilter->SetEddyGradientStrength(m_ImageGenParameters.eddyStrength);
         tractsToDwiFilter->SetUpsampling(m_ImageGenParameters.upsampling);
         tractsToDwiFilter->SetSimulateRelaxation(m_ImageGenParameters.doSimulateRelaxation);
         tractsToDwiFilter->SetImageRegion(m_ImageGenParameters.imageRegion);
         tractsToDwiFilter->SetSpacing(m_ImageGenParameters.imageSpacing);
         tractsToDwiFilter->SetOrigin(m_ImageGenParameters.imageOrigin);
         tractsToDwiFilter->SetDirectionMatrix(m_ImageGenParameters.imageDirection);
         tractsToDwiFilter->SetFiberBundle(fiberBundle);
         tractsToDwiFilter->SetFiberModels(m_ImageGenParameters.fiberModelList);
         tractsToDwiFilter->SetNonFiberModels(m_ImageGenParameters.nonFiberModelList);
         tractsToDwiFilter->SetNoiseModel(&m_ImageGenParameters.ricianNoiseModel);
         tractsToDwiFilter->SetKspaceArtifacts(m_ImageGenParameters.artifactList);
         tractsToDwiFilter->SetkOffset(m_ImageGenParameters.kspaceLineOffset);
         tractsToDwiFilter->SettLine(m_ImageGenParameters.tLine);
         tractsToDwiFilter->SettInhom(m_ImageGenParameters.tInhom);
         tractsToDwiFilter->SetTE(m_ImageGenParameters.tEcho);
         tractsToDwiFilter->SetNumberOfRepetitions(m_ImageGenParameters.repetitions);
         tractsToDwiFilter->SetEnforcePureFiberVoxels(m_ImageGenParameters.doDisablePartialVolume);
         tractsToDwiFilter->SetInterpolationShrink(m_ImageGenParameters.interpolationShrink);
         tractsToDwiFilter->SetFiberRadius(m_ImageGenParameters.axonRadius);
         tractsToDwiFilter->SetSignalScale(m_ImageGenParameters.signalScale);
         if (m_ImageGenParameters.interpolationShrink)
             tractsToDwiFilter->SetUseInterpolation(true);
         tractsToDwiFilter->SetTissueMask(m_ImageGenParameters.tissueMaskImage);
         tractsToDwiFilter->SetFrequencyMap(m_ImageGenParameters.frequencyMap);
 
         tractsToDwiFilter->Update();
 
         mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
         image->SetVectorImage( tractsToDwiFilter->GetOutput() );
         image->SetB_Value(m_ImageGenParameters.b_value);
         image->SetDirections(m_ImageGenParameters.gradientDirections);
         image->InitializeFromVectorImage();
         m_ImageGenParameters.resultNode->SetData( image );
         m_ImageGenParameters.resultNode->SetName(m_SelectedBundles.at(i)->GetName()
                                                  +"_D"+QString::number(m_ImageGenParameters.imageRegion.GetSize(0)).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageRegion.GetSize(1)).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageRegion.GetSize(2)).toStdString()
                                                  +"_S"+QString::number(m_ImageGenParameters.imageSpacing[0]).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageSpacing[1]).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageSpacing[2]).toStdString()
                                                  +"_b"+QString::number(m_ImageGenParameters.b_value).toStdString()
                                                  +"_"+m_ImageGenParameters.signalModelString.toStdString()
                                                  +m_ImageGenParameters.artifactModelString.toStdString());
 
         GetDataStorage()->Add(m_ImageGenParameters.resultNode, m_SelectedBundles.at(i));
 
         m_ImageGenParameters.resultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(tractsToDwiFilter->GetLevelWindow()) );
 
         if (m_Controls->m_VolumeFractionsBox->isChecked())
         {
             std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = tractsToDwiFilter->GetVolumeFractions();
             for (int k=0; k<volumeFractions.size(); k++)
             {
                 mitk::Image::Pointer image = mitk::Image::New();
                 image->InitializeByItk(volumeFractions.at(k).GetPointer());
                 image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
 
                 mitk::DataNode::Pointer node = mitk::DataNode::New();
                 node->SetData( image );
                 node->SetName(m_SelectedBundles.at(i)->GetName()+"_CompartmentVolume-"+QString::number(k).toStdString());
                 GetDataStorage()->Add(node, m_SelectedBundles.at(i));
             }
         }
 
         mitk::BaseData::Pointer basedata = m_ImageGenParameters.resultNode->GetData();
         if (basedata.IsNotNull())
         {
             mitk::RenderingManager::GetInstance()->InitializeViews(
                         basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
     }
 }
 
 void QmitkFiberfoxView::ApplyTransform()
 {
     vector< mitk::DataNode::Pointer > selectedBundles;
     for( int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
             if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
                 selectedBundles.push_back(fibNode);
         }
     }
     if (selectedBundles.empty())
         selectedBundles = m_SelectedBundles2;
 
     if (!selectedBundles.empty())
     {
         std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin();
         for (it; it!=selectedBundles.end(); ++it)
         {
             mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
             fib->RotateAroundAxis(m_Controls->m_XrotBox->value(), m_Controls->m_YrotBox->value(), m_Controls->m_ZrotBox->value());
             fib->TranslateFibers(m_Controls->m_XtransBox->value(), m_Controls->m_YtransBox->value(), m_Controls->m_ZtransBox->value());
             fib->ScaleFibers(m_Controls->m_XscaleBox->value(), m_Controls->m_YscaleBox->value(), m_Controls->m_ZscaleBox->value());
 
             // handle child fiducials
             if (m_Controls->m_IncludeFiducials->isChecked())
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Geometry3D* geom = pe->GetGeometry();
 
                         // translate
                         mitk::Vector3D world;
                         world[0] = m_Controls->m_XtransBox->value();
                         world[1] = m_Controls->m_YtransBox->value();
                         world[2] = m_Controls->m_ZtransBox->value();
                         geom->Translate(world);
 
                         // calculate rotation matrix
                         double x = m_Controls->m_XrotBox->value()*M_PI/180;
                         double y = m_Controls->m_YrotBox->value()*M_PI/180;
                         double z = m_Controls->m_ZrotBox->value()*M_PI/180;
 
                         itk::Matrix< float, 3, 3 > rotX; rotX.SetIdentity();
                         rotX[1][1] = cos(x);
                         rotX[2][2] = rotX[1][1];
                         rotX[1][2] = -sin(x);
                         rotX[2][1] = -rotX[1][2];
 
                         itk::Matrix< float, 3, 3 > rotY; rotY.SetIdentity();
                         rotY[0][0] = cos(y);
                         rotY[2][2] = rotY[0][0];
                         rotY[0][2] = sin(y);
                         rotY[2][0] = -rotY[0][2];
 
                         itk::Matrix< float, 3, 3 > rotZ; rotZ.SetIdentity();
                         rotZ[0][0] = cos(z);
                         rotZ[1][1] = rotZ[0][0];
                         rotZ[0][1] = -sin(z);
                         rotZ[1][0] = -rotZ[0][1];
 
                         itk::Matrix< float, 3, 3 > rot = rotZ*rotY*rotX;
 
                         // transform control point coordinate into geometry translation
                         geom->SetOrigin(pe->GetWorldControlPoint(0));
                         mitk::Point2D cp; cp.Fill(0.0);
                         pe->SetControlPoint(0, cp);
 
                         // rotate fiducial
                         geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
 
                         // implicit translation
                         mitk::Vector3D trans;
                         trans[0] = geom->GetOrigin()[0]-fib->GetGeometry()->GetCenter()[0];
                         trans[1] = geom->GetOrigin()[1]-fib->GetGeometry()->GetCenter()[1];
                         trans[2] = geom->GetOrigin()[2]-fib->GetGeometry()->GetCenter()[2];
                         mitk::Vector3D newWc = rot*trans;
                         newWc = newWc-trans;
                         geom->Translate(newWc);
                     }
                 }
             }
         }
     }
     else
     {
         for (int i=0; i<m_SelectedFiducials.size(); i++)
         {
             mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
             mitk::Geometry3D* geom = pe->GetGeometry();
 
             // translate
             mitk::Vector3D world;
             world[0] = m_Controls->m_XtransBox->value();
             world[1] = m_Controls->m_YtransBox->value();
             world[2] = m_Controls->m_ZtransBox->value();
             geom->Translate(world);
 
             // calculate rotation matrix
             double x = m_Controls->m_XrotBox->value()*M_PI/180;
             double y = m_Controls->m_YrotBox->value()*M_PI/180;
             double z = m_Controls->m_ZrotBox->value()*M_PI/180;
             itk::Matrix< float, 3, 3 > rotX; rotX.SetIdentity();
             rotX[1][1] = cos(x);
             rotX[2][2] = rotX[1][1];
             rotX[1][2] = -sin(x);
             rotX[2][1] = -rotX[1][2];
             itk::Matrix< float, 3, 3 > rotY; rotY.SetIdentity();
             rotY[0][0] = cos(y);
             rotY[2][2] = rotY[0][0];
             rotY[0][2] = sin(y);
             rotY[2][0] = -rotY[0][2];
             itk::Matrix< float, 3, 3 > rotZ; rotZ.SetIdentity();
             rotZ[0][0] = cos(z);
             rotZ[1][1] = rotZ[0][0];
             rotZ[0][1] = -sin(z);
             rotZ[1][0] = -rotZ[0][1];
             itk::Matrix< float, 3, 3 > rot = rotZ*rotY*rotX;
 
             // transform control point coordinate into geometry translation
             geom->SetOrigin(pe->GetWorldControlPoint(0));
             mitk::Point2D cp; cp.Fill(0.0);
             pe->SetControlPoint(0, cp);
 
             // rotate fiducial
             geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
         }
         if (m_Controls->m_RealTimeFibers->isChecked())
             GenerateFibers();
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::CopyBundles()
 {
     if ( m_SelectedBundles.size()<1 ){
         QMessageBox::information( NULL, "Warning", "Select at least one fiber bundle!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least one fiber bundle!";
         return;
     }
 
     std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
     for (it; it!=m_SelectedBundles.end(); ++it)
     {
         // find parent image
         mitk::DataNode::Pointer parentNode;
         mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(*it);
         for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
         {
             mitk::DataNode::Pointer pImgNode = *it2;
             if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
             {
                 parentNode = pImgNode;
                 break;
             }
         }
 
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
         mitk::FiberBundleX::Pointer newBundle = fib->GetDeepCopy();
         QString name((*it)->GetName().c_str());
         name += "_copy";
 
         mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
         fbNode->SetData(newBundle);
         fbNode->SetName(name.toStdString());
         fbNode->SetVisibility(true);
         if (parentNode.IsNotNull())
             GetDataStorage()->Add(fbNode, parentNode);
         else
             GetDataStorage()->Add(fbNode);
 
         // copy child fiducials
         if (m_Controls->m_IncludeFiducials->isChecked())
         {
             mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
             for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
             {
                 mitk::DataNode::Pointer fiducialNode = *it2;
                 if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                 {
                     mitk::PlanarEllipse::Pointer pe = mitk::PlanarEllipse::New();
                     pe->DeepCopy(dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()));
                     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
                     newNode->SetData(pe);
                     newNode->SetName(fiducialNode->GetName());
                     GetDataStorage()->Add(newNode, fbNode);
                 }
             }
         }
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::JoinBundles()
 {
     if ( m_SelectedBundles.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
     std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
     QString name("");
     name += QString((*it)->GetName().c_str());
     ++it;
     for (it; it!=m_SelectedBundles.end(); ++it)
     {
         newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()));
         name += "+"+QString((*it)->GetName().c_str());
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::UpdateGui()
 {
     m_Controls->m_FiberBundleLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_GeometryFrame->setEnabled(true);
     m_Controls->m_GeometryMessage->setVisible(false);
     m_Controls->m_DiffusionPropsMessage->setVisible(false);
     m_Controls->m_FiberGenMessage->setVisible(true);
 
     m_Controls->m_TransformBundlesButton->setEnabled(false);
     m_Controls->m_CopyBundlesButton->setEnabled(false);
     m_Controls->m_GenerateFibersButton->setEnabled(false);
     m_Controls->m_FlipButton->setEnabled(false);
     m_Controls->m_CircleButton->setEnabled(false);
     m_Controls->m_BvalueBox->setEnabled(true);
     m_Controls->m_NumGradientsBox->setEnabled(true);
     m_Controls->m_JoinBundlesButton->setEnabled(false);
     m_Controls->m_AlignOnGrid->setEnabled(false);
 
     if (m_SelectedFiducial.IsNotNull())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_FlipButton->setEnabled(true);
         m_Controls->m_AlignOnGrid->setEnabled(true);
     }
 
     if (m_SelectedImage.IsNotNull() || !m_SelectedBundles.empty())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_CircleButton->setEnabled(true);
         m_Controls->m_FiberGenMessage->setVisible(false);
         m_Controls->m_AlignOnGrid->setEnabled(true);
     }
 
     if (m_TissueMask.IsNotNull() || m_SelectedImage.IsNotNull())
     {
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
     if (m_SelectedDWI.IsNotNull())
     {
         m_Controls->m_DiffusionPropsMessage->setVisible(true);
         m_Controls->m_BvalueBox->setEnabled(false);
         m_Controls->m_NumGradientsBox->setEnabled(false);
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
     if (!m_SelectedBundles.empty())
     {
         m_Controls->m_CopyBundlesButton->setEnabled(true);
         m_Controls->m_GenerateFibersButton->setEnabled(true);
         m_Controls->m_FiberBundleLabel->setText(m_SelectedBundles.at(0)->GetName().c_str());
 
         if (m_SelectedBundles.size()>1)
             m_Controls->m_JoinBundlesButton->setEnabled(true);
     }
 }
 
 void QmitkFiberfoxView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
 {
     m_SelectedBundles2.clear();
     m_SelectedImages.clear();
     m_SelectedFiducials.clear();
     m_SelectedFiducial = NULL;
     m_TissueMask = NULL;
     m_SelectedBundles.clear();
     m_SelectedImage = NULL;
     m_SelectedDWI = NULL;
     m_Controls->m_TissueMaskLabel->setText("<font color='grey'>optional</font>");
 
     // iterate all selected objects, adjust warning visibility
     for( int i=0; i<nodes.size(); i++)
     {
         mitk::DataNode::Pointer node = nodes.at(i);
 
         if ( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
         {
             m_SelectedDWI = node;
             m_SelectedImage = node;
             m_SelectedImages.push_back(node);
         }
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             m_SelectedImages.push_back(node);
             m_SelectedImage = node;
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
             {
                 m_TissueMask = dynamic_cast<mitk::Image*>(node->GetData());
                 m_Controls->m_TissueMaskLabel->setText(node->GetName().c_str());
             }
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
         {
             m_SelectedBundles2.push_back(node);
             if (m_Controls->m_RealTimeFibers->isChecked())
             {
                 m_SelectedBundles.push_back(node);
                 mitk::FiberBundleX::Pointer newFib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
                 if (newFib->GetNumFibers()!=m_Controls->m_FiberDensityBox->value())
                     GenerateFibers();
             }
             else
                 m_SelectedBundles.push_back(node);
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
         {
             m_SelectedFiducials.push_back(node);
             m_SelectedFiducial = node;
             m_SelectedBundles.clear();
             mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(node);
             for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             {
                 mitk::DataNode::Pointer pNode = *it;
                 if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pNode->GetData()) )
                     m_SelectedBundles.push_back(pNode);
             }
         }
     }
     UpdateGui();
 }
 
 
 void QmitkFiberfoxView::EnableCrosshairNavigation()
 {
     MITK_DEBUG << "EnableCrosshairNavigation";
 
     // enable the crosshair navigation
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "enabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(true);
         //        linkedRenderWindow->EnableSlicingPlanes(true);
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::DisableCrosshairNavigation()
 {
     MITK_DEBUG << "DisableCrosshairNavigation";
 
     // disable the crosshair navigation during the drawing
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "disabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(false);
         //        linkedRenderWindow->EnableSlicingPlanes(false);
     }
 }
 
 void QmitkFiberfoxView::NodeRemoved(const mitk::DataNode* node)
 {
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(nonConstNode);
 
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
 
         // remove observers
         data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
         data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
         data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
         data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
         m_DataNodeToPlanarFigureData.erase( it );
     }
 }
 
 void QmitkFiberfoxView::NodeAdded( const mitk::DataNode* node )
 {
     // add observer for selection in renderwindow
     mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
     bool isPositionMarker (false);
     node->GetBoolProperty("isContourMarker", isPositionMarker);
     if( figure && !isPositionMarker )
     {
         MITK_DEBUG << "figure added. will add interactor if needed.";
         mitk::PlanarFigureInteractor::Pointer figureInteractor
                 = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
         mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
         if(figureInteractor.IsNull())
         {
           figureInteractor = mitk::PlanarFigureInteractor::New();
           us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "PlanarFigure" );
           figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
           figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
           figureInteractor->SetDataNode( nonConstNode );
         }
 
         MITK_DEBUG << "will now add observers for planarfigure";
         QmitkPlanarFigureData data;
         data.m_Figure = figure;
 
         //        // add observer for event when figure has been placed
         typedef itk::SimpleMemberCommand< QmitkFiberfoxView > SimpleCommandType;
         //        SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
         //        initializationCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureInitialized );
         //        data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
         // add observer for event when figure is picked (selected)
         typedef itk::MemberCommand< QmitkFiberfoxView > MemberCommandType;
         MemberCommandType::Pointer selectCommand = MemberCommandType::New();
         selectCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureSelected );
         data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
         // add observer for event when interaction with figure starts
         SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
         startInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::DisableCrosshairNavigation);
         data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
         // add observer for event when interaction with figure starts
         SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
         endInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::EnableCrosshairNavigation);
         data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
         m_DataNodeToPlanarFigureData[nonConstNode] = data;
     }
 }
 
 void QmitkFiberfoxView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
     mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPf = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
     mitk::DataStorage::SetOfObjects::ConstPointer allPfs = this->GetDataStorage()->GetSubset( isPf );
     for ( mitk::DataStorage::SetOfObjects::const_iterator it = allPfs->begin(); it!=allPfs->end(); ++it)
     {
         mitk::DataNode* node = *it;
 
         if( node->GetData() == object )
         {
             node->SetSelected(true);
             m_SelectedFiducial = node;
         }
         else
             node->SetSelected(false);
     }
     UpdateGui();
     this->RequestRenderWindowUpdate();
 }
 
 void QmitkFiberfoxView::SetFocus()
 {
     m_Controls->m_CircleButton->setFocus();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
index 9e542190b8..f1e7fba451 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
@@ -1,1064 +1,1062 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include "QmitkQBallReconstructionView.h"
 #include "mitkDiffusionImagingConfigure.h"
 
 // qt includes
 #include <QMessageBox>
 
 // itk includes
 #include "itkTimeProbe.h"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 
 #include "itkDiffusionQballReconstructionImageFilter.h"
 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
 #include "itkDiffusionMultiShellQballReconstructionImageFilter.h"
 #include "itkVectorContainer.h"
 
 #include "mitkQBallImage.h"
 #include "mitkProperties.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 
 #include "berryIStructuredSelection.h"
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
-#ifndef Q_MOC_RUN
-#  include <boost/version.hpp>
-#endif
+#include <boost/version.hpp>
 
 const std::string QmitkQBallReconstructionView::VIEW_ID = "org.mitk.views.qballreconstruction";
 
 
 typedef float TTensorPixelType;
 
 const int QmitkQBallReconstructionView::nrconvkernels = 252;
 
 
 struct QbrShellSelection
 {
   QmitkQBallReconstructionView* m_View;
   mitk::DataNode * m_Node;
   std::string m_NodeName;
 
   std::vector<QCheckBox *> m_CheckBoxes;
   QLabel * m_Label;
 
   mitk::DiffusionImage<DiffusionPixelType> * m_Image;
   typedef mitk::DiffusionImage<DiffusionPixelType>::BValueMap  BValueMap;
 
   QbrShellSelection(QmitkQBallReconstructionView* view, mitk::DataNode * node)
     : m_View(view),
       m_Node(node),
       m_NodeName(node->GetName())
   {
     m_Image = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType> * > (node->GetData());
     if(!m_Image){MITK_INFO << "QmitkQBallReconstructionView::QbrShellSelection : fail to initialize DiffusionImage "; return;}
 
     GenerateCheckboxes();
 
   }
 
   void GenerateCheckboxes()
   {
     BValueMap origMap = m_Image->GetB_ValueMap();
     BValueMap::iterator itStart = origMap.begin();
     itStart++;
     BValueMap::iterator itEnd = origMap.end();
 
     m_Label = new QLabel(m_NodeName.c_str());
     m_Label->setVisible(true);
     m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(m_Label);
 
     for(BValueMap::iterator it = itStart ; it!= itEnd; it++)
     {
       QCheckBox * box  = new QCheckBox(QString::number(it->first));
       m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(box);
 
       box->setChecked(true);
       box->setCheckable(true);
       // box->setVisible(true);
       m_CheckBoxes.push_back(box);
     }
   }
 
   void SetVisible(bool vis)
   {
     foreach(QCheckBox * box, m_CheckBoxes)
     {
       box->setVisible(vis);
     }
   }
 
   BValueMap GetBValueSelctionMap()
   {
     BValueMap inputMap = m_Image->GetB_ValueMap();
     BValueMap outputMap;
 
     unsigned int val = 0;
 
     if(inputMap.find(0) == inputMap.end()){
       MITK_INFO << "QbrShellSelection: return empty BValueMap from GUI Selection";
       return outputMap;
     }else{
       outputMap[val] = inputMap[val];
       MITK_INFO << val;
     }
 
     foreach(QCheckBox * box, m_CheckBoxes)
     {
       if(box->isChecked()){
         val = box->text().toDouble();
         outputMap[val] = inputMap[val];
         MITK_INFO << val;
       }
     }
 
     return outputMap;
   }
 
   ~QbrShellSelection()
   {
     m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget(m_Label);
     delete m_Label;
 
     for(std::vector<QCheckBox *>::iterator it = m_CheckBoxes.begin() ; it!= m_CheckBoxes.end(); it++)
     {
       m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget((*it));
       delete (*it);
     }
     m_CheckBoxes.clear();
   }
 };
 
 using namespace berry;
 
 struct QbrSelListener : ISelectionListener
 {
 
   berryObjectMacro(QbrSelListener);
 
   QbrSelListener(QmitkQBallReconstructionView* view)
   {
     m_View = view;
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
     // save current selection in member variable
     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
 
     // do something with the selected items
     if(m_View->m_CurrentSelection)
     {
       bool foundDwiVolume = false;
 
       m_View->m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
       m_View->m_Controls->m_InputData->setTitle("Please Select Input Data");
 
       QString selected_images = "";
 
       mitk::DataStorage::SetOfObjects::Pointer set =
           mitk::DataStorage::SetOfObjects::New();
 
       int at = 0;
 
       // iterate selection
       for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
            i != m_View->m_CurrentSelection->End(); ++i)
       {
 
         // extract datatree node
         if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
         {
           mitk::DataNode::Pointer node = nodeObj->GetDataNode();
           mitk::DiffusionImage<DiffusionPixelType>* diffusionImage;
           // only look at interesting types
           if(diffusionImage = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType> * >(node->GetData()))
           {
             foundDwiVolume = true;
             selected_images += QString(node->GetName().c_str());
             if(i + 1 != m_View->m_CurrentSelection->End())
               selected_images += "\n";
             set->InsertElement(at++, node);
           }
         }
       }
       m_View->GenerateShellSelectionUI(set);
       m_View->m_Controls->m_DiffusionImageLabel->setText(selected_images);
       m_View->m_Controls->m_ButtonStandard->setEnabled(foundDwiVolume);
       if (foundDwiVolume)
         m_View->m_Controls->m_InputData->setTitle("Input Data");
       else
         m_View->m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     }
   }
 
   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
   {
     // check, if selection comes from datamanager
     if (part)
     {
       QString partname(part->GetPartName().c_str());
       if(partname.compare("Datamanager")==0)
       {
 
         // apply selection
         DoSelectionChanged(selection);
 
       }
     }
   }
 
   QmitkQBallReconstructionView* m_View;
 };
 
 
 // --------------- QmitkQBallReconstructionView----------------- //
 
 
 QmitkQBallReconstructionView::QmitkQBallReconstructionView()
   : QmitkFunctionality(),
     m_Controls(NULL),
     m_MultiWidget(NULL)
 {
 }
 
 QmitkQBallReconstructionView::QmitkQBallReconstructionView(const QmitkQBallReconstructionView& other)
 {
   Q_UNUSED(other);
   throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkQBallReconstructionView::~QmitkQBallReconstructionView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 void QmitkQBallReconstructionView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkQBallReconstructionViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
 
     QStringList items;
     items << "2" << "4" << "6" << "8" << "10" << "12";
     m_Controls->m_QBallReconstructionMaxLLevelComboBox->addItems(items);
     m_Controls->m_QBallReconstructionMaxLLevelComboBox->setCurrentIndex(1);
     MethodChoosen(m_Controls->m_QBallReconstructionMethodComboBox->currentIndex());
 
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     m_Controls->m_QBallReconstructionMethodComboBox->removeItem(3);
 #endif
 
     AdvancedCheckboxClicked();
   }
 
   m_SelListener = berry::ISelectionListener::Pointer(new QbrSelListener(this));
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
   berry::ISelection::ConstPointer sel(
         this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<QbrSelListener>()->DoSelectionChanged(sel);
 }
 
 void QmitkQBallReconstructionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkQBallReconstructionView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkQBallReconstructionView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_ButtonStandard), SIGNAL(clicked()), this, SLOT(ReconstructStandard()) );
     connect( (QObject*)(m_Controls->m_AdvancedCheckbox), SIGNAL(clicked()), this, SLOT(AdvancedCheckboxClicked()) );
     connect( (QObject*)(m_Controls->m_QBallReconstructionMethodComboBox), SIGNAL(currentIndexChanged(int)), this, SLOT(MethodChoosen(int)) );
 
   }
 }
 
 void QmitkQBallReconstructionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
 
 }
 
 void QmitkQBallReconstructionView::Activated()
 {
   QmitkFunctionality::Activated();
 
   berry::ISelection::ConstPointer sel(
         this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<QbrSelListener>()->DoSelectionChanged(sel);
 }
 
 void QmitkQBallReconstructionView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkQBallReconstructionView::ReconstructStandard()
 {
 
   int index = m_Controls->m_QBallReconstructionMethodComboBox->currentIndex();
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
   if(index>=3)
   {
     index = index + 1;
   }
 #endif
 
   switch(index)
   {
   case 0:
   {
     // Numerical
     Reconstruct(0,0);
     break;
   }
   case 1:
   {
     // Standard
     Reconstruct(1,0);
     break;
   }
   case 2:
   {
     // Solid Angle
     Reconstruct(1,6);
     break;
   }
   case 3:
   {
     // Constrained Solid Angle
     Reconstruct(1,7);
     break;
   }
   case 4:
   {
     // ADC
     Reconstruct(1,4);
     break;
   }
   case 5:
   {
     // Raw Signal
     Reconstruct(1,5);
     break;
   }
   case 6:
   {
     // Q-Ball reconstruction
     Reconstruct(2,0);
     break;
   }
   }
 }
 
 void QmitkQBallReconstructionView::MethodChoosen(int method)
 {
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
   if(method>=3)
   {
     method = method + 1;
   }
 #endif
 
   m_Controls->m_QBallSelectionBox->setHidden(true);
   m_Controls->m_OutputCoeffsImage->setHidden(true);
 
   if (method==0)
     m_Controls->m_ShFrame->setVisible(false);
   else
     m_Controls->m_ShFrame->setVisible(true);
 
   switch(method)
   {
   case 0:
     m_Controls->m_Description->setText("Numerical recon. (Tuch 2004)");
     break;
   case 1:
     m_Controls->m_Description->setText("Spherical harmonics recon. (Descoteaux 2007)");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 2:
     m_Controls->m_Description->setText("SH recon. with solid angle consideration (Aganj 2009)");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 3:
     m_Controls->m_Description->setText("SH solid angle with non-neg. constraint (Goh 2009)");
     break;
   case 4:
     m_Controls->m_Description->setText("SH recon. of the plain ADC-profiles");
     break;
   case 5:
     m_Controls->m_Description->setText("SH recon. of the raw diffusion signal");
     break;
   case 6:
     m_Controls->m_Description->setText("SH recon. of the multi shell diffusion signal (Aganj 2010)");
     m_Controls->m_QBallSelectionBox->setHidden(false);
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   }
 }
 
 
 
 void QmitkQBallReconstructionView::AdvancedCheckboxClicked()
 {
   bool check = m_Controls->m_AdvancedCheckbox->isChecked();
 
   m_Controls->m_QBallReconstructionMaxLLevelTextLabel_2->setVisible(check);
   m_Controls->m_QBallReconstructionMaxLLevelComboBox->setVisible(check);
   m_Controls->m_QBallReconstructionLambdaTextLabel_2->setVisible(check);
   m_Controls->m_QBallReconstructionLambdaLineEdit->setVisible(check);
 
   m_Controls->m_QBallReconstructionThresholdLabel_2->setVisible(check);
   m_Controls->m_QBallReconstructionThreasholdEdit->setVisible(check);
   m_Controls->label_2->setVisible(check);
   m_Controls->frame_2->setVisible(check);
 }
 
 void QmitkQBallReconstructionView::Reconstruct(int method, int normalization)
 {
   if (m_CurrentSelection)
   {
     mitk::DataStorage::SetOfObjects::Pointer set =
         mitk::DataStorage::SetOfObjects::New();
 
     int at = 0;
     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
          i != m_CurrentSelection->End();
          ++i)
     {
 
       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
         if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     if(method == 0)
     {
       NumericalQBallReconstruction(set, normalization);
     }
     else
     {
 #if BOOST_VERSION / 100000 > 0
 #if BOOST_VERSION / 100 % 1000 > 34
       if(method == 1)
       {
         AnalyticalQBallReconstruction(set, normalization);
       }
       if(method == 2)
       {
         MultiQBallReconstruction(set);
       }
 #else
       std::cout << "ERROR: Boost 1.35 minimum required" << std::endl;
       QMessageBox::warning(NULL,"ERROR","Boost 1.35 minimum required");
 #endif
 #else
       std::cout << "ERROR: Boost 1.35 minimum required" << std::endl;
       QMessageBox::warning(NULL,"ERROR","Boost 1.35 minimum required");
 #endif
     }
   }
 }
 
 void QmitkQBallReconstructionView::NumericalQBallReconstruction
 (mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization)
 {
   try
   {
     itk::TimeProbe clock;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     std::vector<mitk::DataNode::Pointer> nodes;
     while ( itemiter != itemiterend ) // for all items
     {
 
       mitk::DiffusionImage<DiffusionPixelType>* vols =
           static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
             (*itemiter)->GetData());
 
       std::string nodename;
       (*itemiter)->GetStringProperty("name", nodename);
       ++itemiter;
 
       // QBALL RECONSTRUCTION
       clock.Start();
       MITK_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
                                                     "QBall reconstruction for %s", nodename.c_str()).toAscii());
 
       typedef itk::DiffusionQballReconstructionImageFilter
           <DiffusionPixelType, DiffusionPixelType, TTensorPixelType, QBALL_ODFSIZE>
           QballReconstructionImageFilterType;
 
       QballReconstructionImageFilterType::Pointer filter =
           QballReconstructionImageFilterType::New();
       filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
       filter->SetBValue(vols->GetB_Value());
       filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
 
       switch(normalization)
       {
       case 0:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
         break;
       }
       case 1:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO_B_VALUE);
         break;
       }
       case 2:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO);
         break;
       }
       case 3:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_NONE);
         break;
       }
       default:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
       }
       }
 
       filter->Update();
       clock.Stop();
       MITK_DEBUG << "took " << clock.GetMeanTime() << "s." ;
 
       // ODFs TO DATATREE
       mitk::QBallImage::Pointer image = mitk::QBallImage::New();
       image->InitializeByItk( filter->GetOutput() );
       //image->SetImportVolume( filter->GetOutput()->GetBufferPointer(), 0, 0, mitk::Image::ImportMemoryManagementType::ManageMemory );
       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
       mitk::DataNode::Pointer node=mitk::DataNode::New();
       node->SetData( image );
       QString newname;
       newname = newname.append(nodename.c_str());
       newname = newname.append("_QN%1").arg(normalization);
       SetDefaultNodeProperties(node, newname.toStdString());
       nodes.push_back(node);
       mitk::ProgressBar::GetInstance()->Progress();
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
       GetDefaultDataStorage()->Add(*nodeIt);
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toAscii());
     m_MultiWidget->RequestUpdate();
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex ;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return ;
   }
 }
 
 void QmitkQBallReconstructionView::AnalyticalQBallReconstruction(
     mitk::DataStorage::SetOfObjects::Pointer inImages,
     int normalization)
 {
   try
   {
     itk::TimeProbe clock;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     std::vector<float> lambdas;
     float minLambda  = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
     lambdas.push_back(minLambda);
     int nLambdas = lambdas.size();
 
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     std::vector<mitk::DataNode::Pointer>* nodes
         = new std::vector<mitk::DataNode::Pointer>();
     while ( itemiter != itemiterend ) // for all items
     {
 
       mitk::DiffusionImage<DiffusionPixelType>* vols =
           static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
             (*itemiter)->GetData());
 
       std::string nodename;
       (*itemiter)->GetStringProperty("name",nodename);
       itemiter++;
 
       // QBALL RECONSTRUCTION
       clock.Start();
       MITK_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
                                                     "QBall reconstruction for %s", nodename.c_str()).toAscii());
 
       for(int i=0; i<nLambdas; i++)
       {
 
         float currentLambda = lambdas[i];
 
         switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
         {
         case 0:
         {
           TemplatedAnalyticalQBallReconstruction<2>(vols, currentLambda, nodename, nodes, normalization);
           break;
         }
         case 1:
         {
           TemplatedAnalyticalQBallReconstruction<4>(vols, currentLambda, nodename, nodes, normalization);
           break;
         }
         case 2:
         {
           TemplatedAnalyticalQBallReconstruction<6>(vols, currentLambda, nodename, nodes, normalization);
           break;
         }
         case 3:
         {
           TemplatedAnalyticalQBallReconstruction<8>(vols, currentLambda, nodename, nodes, normalization);
           break;
         }
         case 4:
         {
           TemplatedAnalyticalQBallReconstruction<10>(vols, currentLambda, nodename, nodes, normalization);
           break;
         }
         case 5:
         {
           TemplatedAnalyticalQBallReconstruction<12>(vols, currentLambda, nodename, nodes, normalization);
           break;
         }
         }
 
         clock.Stop();
         MITK_DEBUG << "took " << clock.GetMeanTime() << "s." ;
         mitk::ProgressBar::GetInstance()->Progress();
 
       }
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes->begin(); nodeIt != nodes->end(); ++nodeIt)
       GetDefaultDataStorage()->Add(*nodeIt);
 
     m_MultiWidget->RequestUpdate();
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toAscii());
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return;
   }
 }
 
 template<int L>
 void QmitkQBallReconstructionView::TemplatedAnalyticalQBallReconstruction(
     mitk::DiffusionImage<DiffusionPixelType>* vols, float lambda,
     std::string nodename, std::vector<mitk::DataNode::Pointer>* nodes,
     int normalization)
 {
   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter
       <DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
   filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
   filter->SetBValue(vols->GetB_Value());
   filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
   filter->SetLambda(lambda);
 
   switch(normalization)
   {
   case 0:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
     break;
   }
   case 1:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO_B_VALUE);
     break;
   }
   case 2:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO);
     break;
   }
   case 3:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_NONE);
     break;
   }
   case 4:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_ADC_ONLY);
     break;
   }
   case 5:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_RAW_SIGNAL);
     break;
   }
   case 6:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
     break;
   }
   case 7:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_NONNEG_SOLID_ANGLE);
     break;
   }
   default:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
   }
   }
 
   filter->Update();
 
   // ODFs TO DATATREE
   mitk::QBallImage::Pointer image = mitk::QBallImage::New();
   image->InitializeByItk( filter->GetOutput() );
   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   QString newname;
   newname = newname.append(nodename.c_str());
   newname = newname.append("_QA%1").arg(normalization);
   SetDefaultNodeProperties(node, newname.toStdString());
   nodes->push_back(node);
 
   if(m_Controls->m_OutputCoeffsImage->isChecked())
   {
     mitk::Image::Pointer coeffsImage = mitk::Image::New();
     coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
     coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
     mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
     coeffsNode->SetData( coeffsImage );
     coeffsNode->SetProperty( "name", mitk::StringProperty::New(
                                QString(nodename.c_str()).append("_coeffs").toStdString()) );
     coeffsNode->SetVisibility(false);
     nodes->push_back(coeffsNode);
   }
 
 }
 
 void QmitkQBallReconstructionView::MultiQBallReconstruction(
     mitk::DataStorage::SetOfObjects::Pointer inImages)
 {
   try
   {
     itk::TimeProbe clock;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     std::vector<float> lambdas;
     float minLambda  = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
     lambdas.push_back(minLambda);
     int nLambdas = lambdas.size();
 
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     std::vector<mitk::DataNode::Pointer>* nodes
         = new std::vector<mitk::DataNode::Pointer>();
     while ( itemiter != itemiterend ) // for all items
     {
 
       mitk::DiffusionImage<DiffusionPixelType>* vols =
           static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
             (*itemiter)->GetData());
 
 
       const mitk::DataNode * nodePointer = (*itemiter).GetPointer();
       std::string nodename;
       (*itemiter)->GetStringProperty("name",nodename);
 
       itemiter++;
 
       // QBALL RECONSTRUCTION
       clock.Start();
       MITK_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
                                                     "QBall reconstruction for %s", nodename.c_str()).toAscii());
 
       for(int i=0; i<nLambdas; i++)
       {
 
         float currentLambda = lambdas[i];
 
         switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
         {
         case 0:
         {
           TemplatedMultiQBallReconstruction<2>(vols, currentLambda, nodePointer, nodes);
           break;
         }
         case 1:
         {
           TemplatedMultiQBallReconstruction<4>(vols, currentLambda, nodePointer, nodes);
           break;
         }
         case 2:
         {
           TemplatedMultiQBallReconstruction<6>(vols, currentLambda, nodePointer, nodes);
           break;
         }
         case 3:
         {
           TemplatedMultiQBallReconstruction<8>(vols, currentLambda, nodePointer, nodes);
           break;
         }
         case 4:
         {
           TemplatedMultiQBallReconstruction<10>(vols, currentLambda, nodePointer, nodes);
           break;
         }
         case 5:
         {
           TemplatedMultiQBallReconstruction<12>(vols, currentLambda, nodePointer, nodes);
           break;
         }
         }
 
         clock.Stop();
         MITK_DEBUG << "took " << clock.GetMeanTime() << "s." ;
         mitk::ProgressBar::GetInstance()->Progress();
 
       }
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes->begin(); nodeIt != nodes->end(); ++nodeIt)
       GetDefaultDataStorage()->Add(*nodeIt);
 
     m_MultiWidget->RequestUpdate();
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toAscii());
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex ;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return ;
   }
 }
 
 template<int L>
 void QmitkQBallReconstructionView::TemplatedMultiQBallReconstruction(
     mitk::DiffusionImage<DiffusionPixelType>* vols, float lambda,
     const mitk::DataNode * dataNodePointer, std::vector<mitk::DataNode::Pointer>* nodes)
 {
   typedef itk::DiffusionMultiShellQballReconstructionImageFilter
       <DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
 
   std::string nodename;
   dataNodePointer->GetStringProperty("name",nodename);
 
   filter->SetBValueMap(m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap());
   filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage(), vols->GetB_Value() );
   filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
   filter->SetLambda(lambda);
 
 
   filter->Update();
 
   // ODFs TO DATATREE
   mitk::QBallImage::Pointer image = mitk::QBallImage::New();
   image->InitializeByItk( filter->GetOutput() );
   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   QString newname;
   newname = newname.append(nodename.c_str());
   newname = newname.append("_QAMultiShell");
   SetDefaultNodeProperties(node, newname.toStdString());
   nodes->push_back(node);
 
   if(m_Controls->m_OutputCoeffsImage->isChecked())
   {
     mitk::Image::Pointer coeffsImage = mitk::Image::New();
     coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
     coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
     mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
     coeffsNode->SetData( coeffsImage );
     coeffsNode->SetProperty( "name", mitk::StringProperty::New(
                                QString(nodename.c_str()).append("_coeffs").toStdString()) );
     nodes->push_back(coeffsNode);
   }
 
 
 }
 
 void QmitkQBallReconstructionView::SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name)
 {
   node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 500 ) );
   node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
   node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
   node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
   node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
   node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
   node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
   node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) );
   node->SetProperty ("layer", mitk::IntProperty::New(100));
   node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
   //node->SetProperty( "opacity", mitk::FloatProperty::New(1.0f) );
 
   node->SetProperty( "name", mitk::StringProperty::New(name) );
 
 }
 
 
 //node->SetProperty( "volumerendering", mitk::BoolProperty::New( false ) );
 //node->SetProperty( "use color", mitk::BoolProperty::New( true ) );
 //node->SetProperty( "texture interpolation", mitk::BoolProperty::New( true ) );
 //node->SetProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
 //node->SetProperty( "layer", mitk::IntProperty::New(0));
 //node->SetProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
 //node->SetOpacity(1.0f);
 //node->SetColor(1.0,1.0,1.0);
 //node->SetVisibility(true);
 //node->SetProperty( "IsQBallVolume", mitk::BoolProperty::New( true ) );
 
 //mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
 //mitk::LevelWindow levelwindow;
 ////  levelwindow.SetAuto( image );
 //levWinProp->SetLevelWindow( levelwindow );
 //node->GetPropertyList()->SetPropertx( "levelwindow", levWinProp );
 
 //// add a default rainbow lookup table for color mapping
 //if(!node->GetProperty("LookupTable"))
 //{
 //  mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
 //  vtkLookupTable* vtkLut = mitkLut->GetVtkLookupTable();
 //  vtkLut->SetHueRange(0.6667, 0.0);
 //  vtkLut->SetTableRange(0.0, 20.0);
 //  vtkLut->Build();
 //  mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
 //  mitkLutProp->SetLookupTable(mitkLut);
 //  node->SetProperty( "LookupTable", mitkLutProp );
 //}
 //if(!node->GetProperty("binary"))
 //  node->SetProperty( "binary", mitk::BoolProperty::New( false ) );
 
 //// add a default transfer function
 //mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
 //node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
 
 //// set foldername as string property
 //mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
 //node->SetProperty( "name", nameProp );
 
 
 void QmitkQBallReconstructionView::GenerateShellSelectionUI(mitk::DataStorage::SetOfObjects::Pointer set)
 {
 
   std::map<const mitk::DataNode * , QbrShellSelection * > tempMap;
 
   const mitk::DataStorage::SetOfObjects::iterator setEnd( set->end() );
   mitk::DataStorage::SetOfObjects::iterator NodeIt( set->begin() );
   while(NodeIt != setEnd)
   {
 
 
     if(m_ShellSelectorMap.find(  (*NodeIt).GetPointer() ) != m_ShellSelectorMap.end())
     {
       tempMap[(*NodeIt).GetPointer()] = m_ShellSelectorMap[(*NodeIt).GetPointer()];
       m_ShellSelectorMap.erase((*NodeIt).GetPointer());
     }else
     {
       tempMap[(*NodeIt).GetPointer()] = new QbrShellSelection(this, (*NodeIt) );
       tempMap[(*NodeIt).GetPointer()]->SetVisible(true);
     }
 
     NodeIt++;
   }
 
   for(std::map<const mitk::DataNode * , QbrShellSelection * >::iterator it = m_ShellSelectorMap.begin(); it != m_ShellSelectorMap.end();it ++)
   {
     delete it->second;
   }
   m_ShellSelectorMap.clear();
   m_ShellSelectorMap = tempMap;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
index edc3d56f03..cf3bc30d4c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
@@ -1,444 +1,442 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkTbssSkeletonizationView.h"
 
 
 #include <itkSkeletonizationFilter.h>
 #include <itkProjectionFilter.h>
 #include <itkDistanceMapFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 
 #include <itkImageFileReader.h>
 
 // mitk
 #include <mitkImagePixelReadAccessor.h>
 
 // Qt
 #include <QInputDialog>
 #include <QMessageBox>
 
 //vtk
 #include <vtkLinearTransform.h>
 #include <vtkMatrix4x4.h>
 
 // Boost
-#ifndef Q_MOC_RUN
-#  include <boost/lexical_cast.hpp>
-#endif
+#include <boost/lexical_cast.hpp>
 
 const std::string QmitkTbssSkeletonizationView::VIEW_ID = "org.mitk.views.tbssskeletonization";
 
 using namespace berry;
 
 
 QmitkTbssSkeletonizationView::QmitkTbssSkeletonizationView()
   : QmitkFunctionality()
   , m_Controls( 0 )
   , m_MultiWidget( NULL )
 {
 
 }
 
 QmitkTbssSkeletonizationView::~QmitkTbssSkeletonizationView()
 {
 }
 
 void QmitkTbssSkeletonizationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
 {
   //datamanager selection changed
   if (!this->IsActivated())
     return;
 
   bool found3dImage = false;
   bool found4dImage = false;
 
   // iterate selection
   for ( int i=0; i<nodes.size(); i++ )
   {
 
 
     // only look at interesting types from valid nodes
     mitk::BaseData* nodeData = nodes[i]->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
           found3dImage = true;
         }
         else if(img->GetDimension() == 4)
         {
           found4dImage = true;
         }
       }
     }
 
   }
 
   this->m_Controls->m_Skeletonize->setEnabled(found3dImage);
   this->m_Controls->m_Project->setEnabled(found3dImage && found4dImage);
   this->m_Controls->m_OutputMask->setEnabled(found3dImage && found4dImage);
   this->m_Controls->m_OutputDistanceMap->setEnabled(found3dImage && found4dImage);
 
 }
 
 
 
 void QmitkTbssSkeletonizationView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkTbssSkeletonizationViewControls;
     m_Controls->setupUi( parent );
     this->CreateConnections();
   }
 
 }
 
 void QmitkTbssSkeletonizationView::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkTbssSkeletonizationView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkTbssSkeletonizationView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_Skeletonize), SIGNAL(clicked()), this, SLOT(Skeletonize() ));
     connect( (QObject*)(m_Controls->m_Project), SIGNAL(clicked()), this, SLOT(Project() ));
   }
 }
 
 
 
 void QmitkTbssSkeletonizationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkTbssSkeletonizationView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 
 void QmitkTbssSkeletonizationView::Skeletonize()
 {
   typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
   SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
 
 
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
 
   mitk::Image::Pointer meanImage = mitk::Image::New();
   std::string name = "";
 
   for ( int i=0; i<nodes.size(); i++ )
   {
     // process only on valid nodes
     mitk::BaseData* nodeData = nodes[i]->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
           meanImage = img;
           name = nodes[i]->GetName();
         }
       }
     }
   }
 
 
   // Calculate skeleton
   FloatImageType::Pointer itkImg = FloatImageType::New();
   mitk::CastToItkImage(meanImage, itkImg);
   skeletonizer->SetInput(itkImg);
   skeletonizer->Update();
 
 
   FloatImageType::Pointer output = skeletonizer->GetOutput();
   mitk::Image::Pointer mitkOutput = mitk::Image::New();
   mitk::CastToMitkImage(output, mitkOutput);
   name += "_skeleton";
   AddToDataStorage(mitkOutput, name);
 
 
 
 }
 
 void QmitkTbssSkeletonizationView::Project()
 {
 
   typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
   typedef itk::ProjectionFilter ProjectionFilterType;
   typedef itk::DistanceMapFilter<FloatImageType, FloatImageType> DistanceMapFilterType;
 
   SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
 
 
 
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
 
   mitk::Image::Pointer meanImage = mitk::Image::New();
   mitk::Image::Pointer subjects = mitk::Image::New();
 
   for ( int i=0; i<nodes.size(); i++ )
   {
     // process only on valid nodes
     mitk::BaseData* nodeData = nodes[i]->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
           meanImage = img;
         }
         else if(img->GetDimension() == 4)
         {
           subjects = img;
         }
       }
     }
 
   }
 
   Float4DImageType::Pointer allFA = ConvertToItk(subjects);
 
 
 
 
   // Calculate skeleton
   FloatImageType::Pointer itkImg = FloatImageType::New();
   mitk::CastToItkImage(meanImage, itkImg);
   skeletonizer->SetInput(itkImg);
   skeletonizer->Update();
 
 
   FloatImageType::Pointer output = skeletonizer->GetOutput();
   mitk::Image::Pointer mitkOutput = mitk::Image::New();
   mitk::CastToMitkImage(output, mitkOutput);
   AddToDataStorage(mitkOutput, "mean_FA_skeletonised");
 
 
 
   // Retrieve direction image needed later by the projection filter
   DirectionImageType::Pointer directionImg = skeletonizer->GetVectorImage();
 
 
   // Calculate distance image
   DistanceMapFilterType::Pointer distanceMapFilter = DistanceMapFilterType::New();
   distanceMapFilter->SetInput(output);
   distanceMapFilter->Update();
   FloatImageType::Pointer distanceMap = distanceMapFilter->GetOutput();
 
   if(m_Controls->m_OutputDistanceMap->isChecked())
   {
     mitk::Image::Pointer mitkDistance = mitk::Image::New();
     mitk::CastToMitkImage(distanceMap, mitkDistance);
     AddToDataStorage(mitkDistance, "distance map");
   }
 
   // Do projection
 
   // Ask a threshold to create a skeleton mask
   double threshold = -1.0;
   while(threshold == -1.0)
   {
     threshold = QInputDialog::getDouble(m_Controls->m_Skeletonize, tr("Specify the FA threshold"),
                                         tr("Threshold:"), QLineEdit::Normal,
                                         0.2);
 
     if(threshold < 0.0 || threshold > 1.0)
     {
       QMessageBox msgBox;
       msgBox.setText("Please choose a value between 0 and 1");
       msgBox.exec();
       threshold = -1.0;
     }
   }
 
   typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> ThresholdFilterType;
   ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New();
   thresholder->SetInput(output);
   thresholder->SetLowerThreshold(threshold);
   thresholder->SetUpperThreshold(std::numeric_limits<float>::max());
   thresholder->SetOutsideValue(0);
   thresholder->SetInsideValue(1);
   thresholder->Update();
 
 
   CharImageType::Pointer thresholdedImg = thresholder->GetOutput();
 
 
   if(m_Controls->m_OutputMask->isChecked())
   {
     mitk::Image::Pointer mitkThresholded = mitk::Image::New();
     mitk::CastToMitkImage(thresholdedImg, mitkThresholded);
     std::string maskName = "skeleton_mask_at_" + boost::lexical_cast<std::string>(threshold);
     AddToDataStorage(mitkThresholded, maskName);
   }
 
 
 
   typedef itk::ImageFileReader< CharImageType > CharReaderType;
   CharReaderType::Pointer reader = CharReaderType::New();
   reader->SetFileName("/local/testing/LowerCingulum_1mm.nii.gz");
   reader->Update();
   CharImageType::Pointer cingulum = reader->GetOutput();
 
 
 
   ProjectionFilterType::Pointer projectionFilter = ProjectionFilterType::New();
   projectionFilter->SetDistanceMap(distanceMap);
   projectionFilter->SetDirections(directionImg);
   projectionFilter->SetAllFA(allFA);
   projectionFilter->SetTube(cingulum);
   projectionFilter->SetSkeleton(thresholdedImg);
   projectionFilter->Project();
 
   Float4DImageType::Pointer projected = projectionFilter->GetProjections();
 
   mitk::Image::Pointer mitkProjections = mitk::Image::New();
   mitk::CastToMitkImage(projected, mitkProjections);
 
   AddToDataStorage(mitkProjections, "all_FA_projected");
 
 
 
 }
 
 void QmitkTbssSkeletonizationView::AddToDataStorage(mitk::Image* img, std::string name)
 {
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "name", mitk::StringProperty::New(name) );
   result->SetData( img );
 
   // add new image to data storage and set as active to ease further processing
   GetDefaultDataStorage()->Add( result );
 }
 
 
 Float4DImageType::Pointer QmitkTbssSkeletonizationView::ConvertToItk(mitk::Image::Pointer image)
 {
 
   Float4DImageType::Pointer output = Float4DImageType::New();
 
   mitk::Geometry3D* geo = image->GetGeometry();
   mitk::Vector3D mitkSpacing = geo->GetSpacing();
   mitk::Point3D mitkOrigin = geo->GetOrigin();
 
   Float4DImageType::SpacingType spacing;
   spacing[0] = mitkSpacing[0];
   spacing[1] = mitkSpacing[1];
   spacing[2] = mitkSpacing[2];
   spacing[3] = 1.0; // todo: check if spacing has length 4
 
   Float4DImageType::PointType origin;
   origin[0] = mitkOrigin[0];
   origin[1] = mitkOrigin[1];
   origin[2] = mitkOrigin[2];
   origin[3] = 0;
 
   Float4DImageType::SizeType size;
   size[0] = image->GetDimension(0);
   size[1] = image->GetDimension(1);
   size[2] = image->GetDimension(2);
   size[3] = image->GetDimension(3);
 
   Float4DImageType::DirectionType dir;
   vtkLinearTransform* lin = geo->GetVtkTransform();
   vtkMatrix4x4 *m = lin->GetMatrix();
 
   dir.Fill(0.0);
   for(int x=0; x<3; x++)
   {
     for(int y=0; y<3; y++)
     {
       dir[x][y] = m->GetElement(x,y);
     }
   }
   dir[3][3] = 1;
 
 
 
   output->SetSpacing(spacing);
   output->SetOrigin(origin);
   output->SetRegions(size);
   output->SetDirection(dir);
   output->Allocate();
 
 
   if(image->GetDimension() == 4)
   {
     int timesteps = image->GetDimension(3);
 
     try{
       // REPLACE THIS METHODE()ConvertToItk) WITH mitk::CastToItk
       mitk::ImagePixelReadAccessor<float,4> imageAccessor(image, image->GetSliceData());
 
       // iterate through the subjects and copy data to output
       for(int t=0; t<timesteps; t++)
       {
         for(int x=0; x<image->GetDimension(0); x++)
         {
           for(int y=0; y<image->GetDimension(1); y++)
           {
             for(int z=0; z<image->GetDimension(2); z++)
             {
               itk::Index<4> ix4;
               ix4[0] = x;
               ix4[1] = y;
               ix4[2] = z;
               ix4[3] = t;
 
               output->SetPixel(ix4, imageAccessor.GetPixelByIndex(ix4));
 
             }
           }
         }
       }
     }catch(std::exception & e)
     {
       MITK_INFO << e.what();
     }
 
   }
 
 
   return output;
 }