diff --git a/CMakeLists.txt b/CMakeLists.txt
index e5e1ce68a4..bcce126453 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,521 +1,523 @@
 cmake_minimum_required(VERSION 2.8.2)
 
 project(MITK)
 
 #-----------------------------------------------------------------------------
 # See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details
 #-----------------------------------------------------------------------------
 
 set(project_policies
   CMP0001 # NEW: CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.
   CMP0002 # NEW: Logical target names must be globally unique.
   CMP0003 # NEW: Libraries linked via full path no longer produce linker search paths.
   CMP0004 # NEW: Libraries linked may NOT have leading or trailing whitespace.
   CMP0005 # NEW: Preprocessor definition values are now escaped automatically.
   CMP0006 # NEW: Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.
   CMP0007 # NEW: List command no longer ignores empty elements.
   CMP0008 # NEW: Libraries linked by full-path must have a valid library file name.
   CMP0009 # NEW: FILE GLOB_RECURSE calls should not follow symlinks by default.
   CMP0010 # NEW: Bad variable reference syntax is an error.
   CMP0011 # NEW: Included scripts do automatic cmake_policy PUSH and POP.
   CMP0012 # NEW: if() recognizes numbers and boolean constants.
   CMP0013 # NEW: Duplicate binary directories are not allowed.
   CMP0014 # NEW: Input directories must have CMakeLists.txt
   )
 foreach(policy ${project_policies})
   if(POLICY ${policy})
     cmake_policy(SET ${policy} NEW)
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #------------------------------------------------------------------------------
 
 set(CMAKE_MODULE_PATH
   ${MITK_SOURCE_DIR}/CMake
   ${CMAKE_MODULE_PATH}
   )
 
 #-----------------------------------------------------------------------------
 # CMake Function(s) and Macro(s)
 #-----------------------------------------------------------------------------
 
 include(mitkMacroEmptyExternalProject)
 include(mitkFunctionGenerateProjectXml)
 
 #-----------------------------------------------------------------------------
 # Superbuild Option - Enabled by default
 #-----------------------------------------------------------------------------
 
 option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON)
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 foreach(type LIBRARY RUNTIME ARCHIVE)
   # Make sure the directory exists
   if(DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY
      AND NOT EXISTS ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     message(FATAL_ERROR "MITK_CMAKE_${type}_OUTPUT_DIRECTORY is set to a non-existing directory [${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}]")
   endif()
   
   if(MITK_USE_SUPERBUILD)
     set(output_dir ${MITK_BINARY_DIR}/bin)
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_BINARY_DIR}/MITK-build/bin)
     endif()
   else()
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       SET(output_dir ${MITK_BINARY_DIR}/bin)
     else()
       SET(output_dir ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     endif()
   endif()
   set(CMAKE_${type}_OUTPUT_DIRECTORY ${output_dir} CACHE INTERNAL "Single output directory for building all libraries.")
   mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Additional MITK Options (also shown during superbuild)
 #-----------------------------------------------------------------------------
 
 option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON)
 option(WITH_COVERAGE "Enable/Disable coverage" OFF)
 option(BUILD_TESTING "Test the project" ON)
 
 # some targets in Utilities also depend on Qt. Use this option
 # to decide if they should be build
 option(MITK_USE_QT "Use Trolltech's Qt library" ON)
 if(MITK_USE_QT)
   # find the package at the very beginning, so that QT4_FOUND is available
   find_package(Qt4 4.6.0 REQUIRED)
 endif()
 
 option(MITK_INSTALL_RPATH_RELATIVE "Use relative rpath entries for installation packages" OFF)
 option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
 option(MITK_BUILD_TUTORIAL "Build the MITK tutorial" ON)
 option(MITK_USE_Boost "Use the Boost C++ library" OFF)
 option(MITK_USE_GDCMIO "Use the GDCMIO class instead of ImageIO2 for DICOM" ON)
 option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
 option(MITK_USE_CTK "EXEPERIMENTAL, superbuild only: Use CTK in MITK" OFF)
 option(MITK_USE_DCMTK "EXEPERIMENTAL, superbuild only: Use DCMTK in MITK" OFF)
   
 mark_as_advanced(MITK_INSTALL_RPATH_RELATIVE
                  MITK_BUILD_ALL_PLUGINS
                  MITK_USE_CTK
                  MITK_USE_DCMTK
                  )
 
 #-----------------------------------------------------------------------------
 # Additional CXX/C Flags
 #-----------------------------------------------------------------------------
 
 set(ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags")
 mark_as_advanced(ADDITIONAL_C_FLAGS)
 set(ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags")
 mark_as_advanced(ADDITIONAL_CXX_FLAGS)
 
 #-----------------------------------------------------------------------------
 # Project.xml
 #-----------------------------------------------------------------------------
 
 # A list of topologically ordered targets
 set(CTEST_PROJECT_SUBPROJECTS)
 if(MITK_USE_BLUEBERRY)
   list(APPEND CTEST_PROJECT_SUBPROJECTS BlueBerry)
 endif()
 
 list(APPEND CTEST_PROJECT_SUBPROJECTS
   MITK-Core
   MITK-CoreUI
   MITK-IGT
   MITK-DTI
   MITK-Registration
   MITK-Modules # all modules not contained in a specific subproject
   MITK-Plugins # all plugins not contained in a specific subproject
   )
 
 # Configure CTestConfigSubProject.cmake that could be used by CTest scripts
 configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in
                ${MITK_BINARY_DIR}/CTestConfigSubProject.cmake)
 
 # Generate Project.xml file expected by the CTest driver script
 mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} ${PROJECT_NAME} "${CTEST_PROJECT_SUBPROJECTS}" ${MITK_USE_SUPERBUILD})
 
 #-----------------------------------------------------------------------------
 # Superbuild script
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_SUPERBUILD)
   include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
   return()
 endif()
 
 #*****************************************************************************
 #****************************  END OF SUPERBUILD  ****************************
 #*****************************************************************************
 
 #-----------------------------------------------------------------------------
 # CMake Function(s) and Macro(s)
 #-----------------------------------------------------------------------------
 
 include(mitkFunctionCheckCompilerFlags)
 include(mitkFunctionGetGccVersion)
 include(MacroParseArguments)
 include(mitkFunctionSuppressWarnings) # includes several functions
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionGetVersion)
 include(mitkFunctionCreateWindowsBatchScript)
 include(mitkMacroCreateModuleConf)
 include(mitkMacroCreateModule)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 
 #-----------------------------------------------------------------------------
 # Prerequesites
 #-----------------------------------------------------------------------------
 
 find_package(ITK REQUIRED)
 find_package(VTK REQUIRED)
 
 #-----------------------------------------------------------------------------
 # Set MITK specific options and variables (NOT available during superbuild)
 #-----------------------------------------------------------------------------
 
 # ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and ExtApp
 option(MITK_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting MITK GUI Applications" ON)
 mark_as_advanced(MITK_SHOW_CONSOLE_WINDOW)
 
 # TODO: check if necessary
 option(USE_ITKZLIB "Use the ITK zlib for pic compression." ON)
 mark_as_advanced(USE_ITKZLIB)
 
 #-----------------------------------------------------------------------------
 # Get MITK version info
 #-----------------------------------------------------------------------------
 
 mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
 
 #-----------------------------------------------------------------------------
 # Set symbol visibility Flags
 #-----------------------------------------------------------------------------
 
 # MinGW does not export all symbols automatically, so no need to set flags
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT MINGW)
   set(VISIBILITY_CXX_FLAGS ) #"-fvisibility=hidden -fvisibility-inlines-hidden")
 endif()
 
 #-----------------------------------------------------------------------------
 # Set coverage Flags
 #-----------------------------------------------------------------------------
 
 if(WITH_COVERAGE)
   if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG")
     set(COVERAGE_CXX_FLAGS ${coverage_flags})
     set(COVERAGE_C_FLAGS ${coverage_flags})
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK C/CXX Flags
 #-----------------------------------------------------------------------------
 
 set(MITK_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_C_FLAGS} ${ADDITIONAL_C_FLAGS}")
 set(MITK_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS} ${ADDITIONAL_CXX_FLAGS}")
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   set(cflags "-Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings -D_FORTIFY_SOURCE=2")
   
   mitkFunctionCheckCompilerFlags("-fdiagnostics-show-option" cflags)
   mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" cflags)
   
   mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
   # With older version of gcc supporting the flag -fstack-protector-all, an extra dependency to libssp.so
   # is introduced. If gcc is smaller than 4.4.0 and the build type is Release let's not include the flag.
   # Doing so should allow to build package made for distribution using older linux distro.
   if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0"))
     mitkFunctionCheckCompilerFlags("-fstack-protector-all" cflags)
   endif()
   if(MINGW)
     # suppress warnings about auto imported symbols
     set(MITK_CXX_FLAGS "-Wl,--enable-auto-import ${MITK_CXX_FLAGS}")  
     # we need to define a Windows version
     set(MITK_CXX_FLAGS "-D_WIN32_WINNT=0x0500 ${MITK_CXX_FLAGS}")
   endif()
   
   set(MITK_C_FLAGS "${cflags} ${MITK_C_FLAGS}")
   #set(MITK_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wold-style-cast -Wstrict-null-sentinel -Wsign-promo ${MITK_CXX_FLAGS}")
   set(MITK_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wstrict-null-sentinel ${MITK_CXX_FLAGS}")
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK Modules
 #-----------------------------------------------------------------------------
 
 set(MITK_MODULES_CONF_DIR ${MITK_BINARY_DIR}/modulesConf CACHE INTERNAL "Modules Conf")
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 
 #-----------------------------------------------------------------------------
 # Testing
 #-----------------------------------------------------------------------------
 
 if(BUILD_TESTING)
   enable_testing()
   include(CTest)
   mark_as_advanced(TCL_TCLSH DART_ROOT)
   
   option(MITK_ENABLE_GUI_TESTING OFF "Enable the MITK GUI tests")
     
   # Setup file for setting custom ctest vars
   configure_file(
     CMake/CTestCustom.cmake.in
     ${MITK_BINARY_DIR}/CTestCustom.cmake
     @ONLY
     )
 
   # Configuration for the CMake-generated test driver
   set(CMAKE_TESTDRIVER_EXTRA_INCLUDES "#include <stdexcept>")
   set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "
     try
       {")
   set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "    }
       catch( std::exception & excp )
         {
         fprintf(stderr,\"%s\\n\",excp.what());
         return EXIT_FAILURE;
         }
       catch( ... )
         {
         printf(\"Exception caught in the test driver\\n\");
         return EXIT_FAILURE;
         }
       ")
       
   set(MITK_TEST_OUTPUT_DIR "${MITK_BINARY_DIR}/test_output")
   if(NOT EXISTS ${MITK_TEST_OUTPUT_DIR})
     file(MAKE_DIRECTORY ${MITK_TEST_OUTPUT_DIR})
   endif()
   configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h)
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK_SUPERBUILD_BINARY_DIR
 #-----------------------------------------------------------------------------
 
 # If MITK_SUPERBUILD_BINARY_DIR isn't defined, it means MITK is *NOT* build using Superbuild.
 # In that specific case, MITK_SUPERBUILD_BINARY_DIR should default to MITK_BINARY_DIR
 if(NOT DEFINED MITK_SUPERBUILD_BINARY_DIR)
   set(MITK_SUPERBUILD_BINARY_DIR ${MITK_BINARY_DIR})
 endif()
 
 #-----------------------------------------------------------------------------
 # Compile Utilities and set-up MITK variables
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Utilities)
 
 include(mitkSetupVariables)
 if(MITK_USE_BLUEBERRY)
   include(mitkSetupBlueBerry)
 endif()
 
 #-----------------------------------------------------------------------------
 # Set C/CXX Flags for MITK code
 #-----------------------------------------------------------------------------
 
 set(CMAKE_CXX_FLAGS ${MITK_CXX_FLAGS})
 set(CMAKE_C_FLAGS ${MITK_C_FLAGS})
 
 if(MITK_USE_QT)
   add_definitions(-DQWT_DLL)
 endif()
 
 #-----------------------------------------------------------------------------
 # Add custom targets representing CDash subprojects
 #-----------------------------------------------------------------------------
 
 foreach(subproject ${CTEST_PROJECT_SUBPROJECTS})
   if(NOT TARGET ${subproject})
     add_custom_target(${subproject})
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 link_directories(${MITK_LINK_DIRECTORIES})
 
 add_subdirectory(Core)
 
 set(MITK_DEFAULT_SUBPROJECTS MITK-CoreUI)
 
 if(MITK_USE_QT AND QT4_FOUND)
   add_subdirectory(CoreUI/Qmitk)
 endif()
 
 add_subdirectory(Modules)
 
 if(MITK_USE_BLUEBERRY)
 
   set(mitk_core_plugins
     CoreUI/Bundles/org.mitk.core.services:ON
     CoreUI/Bundles/org.mitk.gui.common:ON
     CoreUI/Bundles/org.mitk.gui.qt.common:ON
     CoreUI/Bundles/org.mitk.gui.qt.application:ON
   )
   
   set(mitk_ext_plugins
     Modules/Bundles/org.mitk.core.ext:ON
     Modules/Bundles/org.mitk.core.jobs:OFF
+    Modules/Bundles/org.mitk.diffusionimaging:OFF
+    Modules/Bundles/org.mitk.gui.qt.diffusionimaging:OFF
     Modules/Bundles/org.mitk.gui.qt.ext:ON
     Modules/Bundles/org.mitk.gui.qt.extapplication:ON
   )
 
   ctkMacroSetupExternalPlugins(${mitk_core_plugins} ${mitk_ext_plugins}
                                BUILD_OPTION_PREFIX MITK_BUILD_
                                BUILD_ALL ${MITK_BUILD_ALL_PLUGINS}
                                COMPACT_OPTIONS)
 
   set(MITK_COREAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.provisioning")
   if(EXISTS "${MITK_COREAPP_PROVISIONING_FILE}")
     file(REMOVE "${MITK_COREAPP_PROVISIONING_FILE}")
   endif()
   file(APPEND "${MITK_COREAPP_PROVISIONING_FILE}" "READ file://${BLUEBERRY_PLUGIN_PROVISIONING_FILE}\n")
 
   FunctionCreateProvisioningInfo(prov_info "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins" ${mitk_core_plugins})
   file(APPEND "${MITK_COREAPP_PROVISIONING_FILE}" "${prov_info}")
 
   
   set(MITK_EXTAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ExtApp.provisioning")
   if(EXISTS "${MITK_EXTAPP_PROVISIONING_FILE}")
     file(REMOVE "${MITK_EXTAPP_PROVISIONING_FILE}")
   endif()
   file(APPEND "${MITK_EXTAPP_PROVISIONING_FILE}" "READ file://${MITK_COREAPP_PROVISIONING_FILE}\n")
 
   FunctionCreateProvisioningInfo(prov_info "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins" ${mitk_ext_plugins})
   file(APPEND "${MITK_EXTAPP_PROVISIONING_FILE}" "${prov_info}")
     
 
   set(MITK_CORE_PLUGIN_USE_FILE "${MITK_BINARY_DIR}/MitkCorePluginUseFile.cmake")
   ctkFunctionGeneratePluginUseFile(${MITK_CORE_PLUGIN_USE_FILE})
 endif()
 
 if(MITK_USE_BLUEBERRY)
   add_subdirectory(Modules/Bundles)
 endif()
 
 add_subdirectory(Applications)
 
 #-----------------------------------------------------------------------------
 # Python Wrapping
 #-----------------------------------------------------------------------------
 
 set(MITK_WRAPPING_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Wrapping)
 set(MITK_WRAPPING_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Wrapping)
 option(MITK_USE_PYTHON "Build cswig Python wrapper support (requires CableSwig)." OFF)
 if(MITK_USE_PYTHON)
   add_subdirectory(Wrapping)
 endif()
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Documentation)
 
 #-----------------------------------------------------------------------------
 # Installation
 #-----------------------------------------------------------------------------
 
 if(MITK_INSTALL_RPATH_RELATIVE)
   set(CMAKE_INSTALL_RPATH ".")
 else()
   set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/bin")
 endif()
 
 # on Mac OSX all BlueBerry plugins get copied into every
 # application bundle (.app directory) specified here
 if(APPLE)
   if(MITK_BUILD_org.mitk.gui.qt.extapplication)
     set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} ExtApp)
   endif()
   if(MITK_BUILD_org.mitk.gui.qt.application)
     set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} CoreApp)
   endif()
 endif(APPLE)
 
 # set MITK cpack variables
 include(mitkSetupCPack)
 
 if(MITK_BUILD_org.mitk.gui.qt.application)
   list(APPEND CPACK_CREATE_DESKTOP_LINKS "CoreApp")
 endif()
 if(MITK_BUILD_org.mitk.gui.qt.extapplication)
   list(APPEND CPACK_CREATE_DESKTOP_LINKS "ExtApp")
 endif()
 
 
 configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
                ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY)
 set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake")
 
 # include CPack model once all variables are set
 include(CPack)
 
 # Additional installation rules
 include(mitkInstallRules)
 
 #-----------------------------------------------------------------------------
 # Last configuration steps
 #-----------------------------------------------------------------------------
 
 set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake")
 file(REMOVE ${MITK_EXPORTS_FILE})
 
 if(MITK_USE_BLUEBERRY)
   set(enabled_plugins
     ${BLUEBERRY_ENABLED_PLUGINS}
     ${MITK_CORE_ENABLED_PLUGINS}
     ${MITK_MODULES_ENABLED_PLUGINS}
     )
 
   # This is for installation support of external projects depending on
   # MITK plugins. The export file should not be used for linking to MITK
   # libraries without using LINK_DIRECTORIES, since the exports are incomplete
   # yet(depending libraries are not exported).
   foreach(plugin ${enabled_plugins})
     string(REPLACE "." "_" plugin_target ${plugin})
     export(TARGETS ${plugin_target}
            APPEND
            FILE ${MITK_EXPORTS_FILE})
   endforeach()
 endif()
 
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY)
 
 configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h)
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 
 set(VECMATH_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/vecmath)
 set(IPFUNC_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipFunc)
 set(UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities)
 
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY)
 
diff --git a/Modules/Bundles/CMakeLists.txt b/Modules/Bundles/CMakeLists.txt
index 65f518d63c..4d5dcc392f 100644
--- a/Modules/Bundles/CMakeLists.txt
+++ b/Modules/Bundles/CMakeLists.txt
@@ -1,43 +1,45 @@
 
 IF(MITK_USE_BLUEBERRY)
 
   # INCLUDE("${MITK_BINARY_DIR}/mitkExtConfig.cmake")
   # INCLUDE("${MITK_BINARY_DIR}/QmitkExtConfig.cmake")
 
   INCLUDE("${MITK_BINARY_DIR}/Bundles/MITKCoreBundleList.cmake")
   
   SET(MITK_DEFAULT_SUBPROJECTS MITK-Plugins)
   
   SET(_mitk_bundles_default 
       "org.mitk.planarfigure"
   )
   
   IF(QT4_FOUND)
     LIST(APPEND _mitk_bundles_default "org.mitk.gui.qt.ext" "org.mitk.gui.qt.extapplication")
     # ExtApp required bundles
     LIST(APPEND _mitk_bundles_default "org.mitk.gui.qt.imagenavigator" "org.mitk.gui.qt.datamanager")
 
     # BlueBerry depends on CTK which depends on Qt, so we
     # need the Qt include direcotries
     INCLUDE(${QT_USE_FILE})
   ENDIF()
   
   SET(PLUGIN_EXCLUDE_LIST
     org.mitk.core.ext
     org.mitk.gui.qt.volumetry
     org.mitk.core.jobs
+    org.mitk.diffusionimaging
+    org.mitk.gui.qt.diffusionimaging
     org.mitk.gui.qt.ext
     org.mitk.gui.qt.extapplication
   )
 
   MACRO_COLLECT_PLUGINS(OUTPUT_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ExtBundles
                         CACHE_PLUGIN_SOURCE_DIRS MITK_MODULES_PLUGIN_SOURCE_DIRS
                         CACHE_PLUGIN_OUTPUT_DIRS MITK_MODULES_PLUGIN_OUTPUT_DIRS
                         CACHE_PLUGIN_TARGETS MITK_MODULES_ENABLED_PLUGINS
                         BUNDLE_LIST_PATH "${MITK_BINARY_DIR}/Bundles/MITKModulesBundleList.cmake" 
                         CMAKE_CACHE_PREFIX "MITK"
                         PLUGIN_DEFAULT_ON ${_mitk_bundles_default}
                         PLUGIN_EXCLUDES ${PLUGIN_EXCLUDE_LIST}
                         ${MITK_BUILD_ALL_PLUGINS_OPTION})
    
 ENDIF(MITK_USE_BLUEBERRY)
diff --git a/Modules/Bundles/org.mitk.diffusionimaging/CMakeLists.txt b/Modules/Bundles/org.mitk.diffusionimaging/CMakeLists.txt
index 4ccff3acb1..3d05bd3950 100644
--- a/Modules/Bundles/org.mitk.diffusionimaging/CMakeLists.txt
+++ b/Modules/Bundles/org.mitk.diffusionimaging/CMakeLists.txt
@@ -1,2 +1,7 @@
+PROJECT(org_mitk_diffusionimaging)
 
-MACRO_CREATE_MITK_PLUGIN(MitkDiffusionImaging Qmitk QmitkExt)
+MACRO_CREATE_MITK_CTK_PLUGIN(
+  EXPORT_DIRECTIVE ORG_MITK_DIFFUSIONIMAGING_EXPORT
+  EXPORTED_INCLUDE_SUFFIXES src
+  MODULE_DEPENDENCIES MitkDiffusionImaging QmitkExt
+)
diff --git a/Modules/Bundles/org.mitk.diffusionimaging/META-INF/MANIFEST.MF b/Modules/Bundles/org.mitk.diffusionimaging/META-INF/MANIFEST.MF
deleted file mode 100644
index a884e68c0e..0000000000
--- a/Modules/Bundles/org.mitk.diffusionimaging/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,8 +0,0 @@
-Manifest-Version: 1.0
-Bundle-Name: MBI DiffusionImaging 
-Bundle-SymbolicName: org.mitk.diffusionimaging 
-Bundle-Version: 0.1
-Bundle-Vendor: DKFZ, Medical and Biological Informatics
-Require-Bundle: org.blueberry.osgi, org.blueberry.ui, org.mitk.gui.common
-Bundle-Activator: mitk::DiffusionImagingActivator
-Bundle-ActivationPolicy: eager
diff --git a/Modules/Bundles/org.mitk.diffusionimaging/files.cmake b/Modules/Bundles/org.mitk.diffusionimaging/files.cmake
index fe07714ba8..3b39ed6c21 100644
--- a/Modules/Bundles/org.mitk.diffusionimaging/files.cmake
+++ b/Modules/Bundles/org.mitk.diffusionimaging/files.cmake
@@ -1,18 +1,22 @@
 SET(SRC_CPP_FILES
   
 )
 
 SET(INTERNAL_CPP_FILES
   mitkDiffusionImagingActivator.cpp
 )
 
-SET(CPP_FILES manifest.cpp)
+SET(MOC_H_FILES
+  src/internal/mitkDiffusionImagingActivator.h
+)
+
+SET(CPP_FILES )
 
 foreach(file ${SRC_CPP_FILES})
   SET(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   SET(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
 
diff --git a/Modules/Bundles/org.mitk.diffusionimaging/manifest.cpp b/Modules/Bundles/org.mitk.diffusionimaging/manifest.cpp
deleted file mode 100644
index 4280b3afef..0000000000
--- a/Modules/Bundles/org.mitk.diffusionimaging/manifest.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*=========================================================================
-
-Program:   Medical Imaging & Interaction Toolkit
-Language:  C++
-Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
-Version:   $Revision: 18127 $
-
-Copyright (c) German Cancer Research Center, Division of Medical and
-Biological Informatics. All rights reserved.
-See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
-
-This software is distributed WITHOUT ANY WARRANTY; without even
-the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
-
-#include <Poco/ClassLibrary.h>
-
-#include <berryIBundleActivator.h>
-#include "src/internal/mitkDiffusionImagingActivator.h"
-
-POCO_BEGIN_MANIFEST(berry::IBundleActivator)
-POCO_EXPORT_CLASS(mitk::DiffusionImagingActivator)
-POCO_END_MANIFEST
diff --git a/Modules/Bundles/org.mitk.diffusionimaging/manifest_headers.cmake b/Modules/Bundles/org.mitk.diffusionimaging/manifest_headers.cmake
new file mode 100644
index 0000000000..e6cfa071fe
--- /dev/null
+++ b/Modules/Bundles/org.mitk.diffusionimaging/manifest_headers.cmake
@@ -0,0 +1,6 @@
+set(Plugin-Name "MBI DiffusionImaging")
+set(Plugin-Version "0.1")
+set(Plugin-Vendor "DKFZ, Medical and Biological Informatics")
+set(Plugin-ContactAddress "http://www.mitk.org")
+set(Require-Plugin org.mitk.gui.common)
+set(Plugin-ActivationPolicy eager)
diff --git a/Modules/Bundles/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp b/Modules/Bundles/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
index e8db5ee8c2..167af0b088 100644
--- a/Modules/Bundles/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
+++ b/Modules/Bundles/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
@@ -1,116 +1,54 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkDiffusionImagingActivator.h"
 #include "mitkDiffusionImagingObjectFactory.h"
 
 #include "QmitkNodeDescriptorManager.h"
 #include "mitkNodePredicateDataType.h"
-//#include "mitkDataNodeObject.h"
-//
-//#include "berryISelectionService.h"
-//#include "berryIStructuredSelection.h"
-//#include "berryPlatformUI.h"
-//
-//#include <QLabel>
-//#include <QHBoxLayout>
+
+#include <QtPlugin>
 
 void
-mitk::DiffusionImagingActivator::Start(berry::IBundleContext::Pointer /*context*/)
+mitk::DiffusionImagingActivator::start(ctkPluginContext* context)
 {
+  Q_UNUSED(context)
+  
   RegisterDiffusionImagingObjectFactory();
 
   QmitkNodeDescriptorManager* manager = 
     QmitkNodeDescriptorManager::GetInstance();
 
   mitk::NodePredicateDataType::Pointer isDiffusionImage = mitk::NodePredicateDataType::New("DiffusionImage");
   QmitkNodeDescriptor* desc = new QmitkNodeDescriptor(QObject::tr("DiffusionImage"), QString(":/QmitkDiffusionImaging/QBallData24.png"), isDiffusionImage, manager);
   manager->AddDescriptor(desc);
 
   mitk::NodePredicateDataType::Pointer isTensorImage = mitk::NodePredicateDataType::New("TensorImage");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("TensorImage"), QString(":/QmitkDiffusionImaging/recontensor.png"), isTensorImage, manager));
 
   mitk::NodePredicateDataType::Pointer isQBallImage = mitk::NodePredicateDataType::New("QBallImage");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("QBallImage"), QString(":/QmitkDiffusionImaging/reconodf.png"), isQBallImage, manager));
 
-  //m_OpacitySlider = new QSlider;
-  //m_OpacitySlider->setMinimum(0);
-  //m_OpacitySlider->setMaximum(100);
-  //m_OpacitySlider->setOrientation(Qt::Horizontal);
-  //QObject::connect( m_OpacitySlider, SIGNAL( valueChanged(int) )
-  //  , this, SLOT( OpactiyChanged(int) ) );
-
-  //QLabel* _OpacityLabel = new QLabel("Channel: ");
-  //QHBoxLayout* _OpacityWidgetLayout = new QHBoxLayout;
-  //_OpacityWidgetLayout->addWidget(_OpacityLabel);
-  //_OpacityWidgetLayout->addWidget(m_OpacitySlider);
-  //QWidget* _OpacityWidget = new QWidget;
-  //_OpacityWidget->setLayout(_OpacityWidgetLayout);
-
-  //QWidgetAction* m_OpacityAction = new QWidgetAction(this);
-  //m_OpacityAction->setDefaultWidget(_OpacityWidget);
-  //QObject::connect( m_OpacityAction, SIGNAL( changed() )
-  //  , this, SLOT( OpactiyActionChanged() ) );
-
-  //  desc->AddAction(m_OpacityAction, false);
+}
 
+void
+mitk::DiffusionImagingActivator::stop(ctkPluginContext* context)
+{
+  Q_UNUSED(context)
 }
 
-//void mitk::DiffusionImagingActivator::OpactiyChanged(int value)
-//{
-//  berry::ISelection::ConstPointer sel(
-//    berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
-//  berry::IStructuredSelection::ConstPointer ssel = sel.Cast<const berry::IStructuredSelection>();
-//
-//  if (ssel)
-//  {
-//    if (mitk::DataNodeObject::Pointer nodeObj = ssel->Begin()->Cast<mitk::DataNodeObject>())
-//    {
-//      mitk::DataNode::Pointer node = nodeObj->GetDataNode();
-//      if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
-//      {
-//        node->SetIntProperty("DisplayChannel", value);
-//        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-//      }
-//    }
-//  }
-//}
-//
-//void mitk::DiffusionImagingActivator::OpactiyActionChanged()
-//{
-//  berry::ISelection::ConstPointer sel(
-//    berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
-//  berry::IStructuredSelection::ConstPointer ssel = sel.Cast<const berry::IStructuredSelection>();
-// 
-//  if (ssel)
-//  {
-//    if (mitk::DataNodeObject::Pointer nodeObj = ssel->Begin()->Cast<mitk::DataNodeObject>())
-//    {
-//      mitk::DataNode::Pointer node = nodeObj->GetDataNode();
-//      if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
-//      {
-//        int displayChannel = 0.0;
-//        if(node->GetIntProperty("DisplayChannel", displayChannel))
-//        {
-//          m_OpacitySlider->setValue(displayChannel);
-//        }
-//      }
-//    }
-//  }
-//
-//  MITK_INFO << "changed";
-//}
\ No newline at end of file
+Q_EXPORT_PLUGIN2(org_mitk_diffusionimaging, mitk::DiffusionImagingActivator)
diff --git a/Modules/Bundles/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.h b/Modules/Bundles/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.h
index 218f3abf82..b0cc568ffa 100644
--- a/Modules/Bundles/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.h
+++ b/Modules/Bundles/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.h
@@ -1,65 +1,54 @@
 /*=========================================================================
 
  Program:   MITK Platform
  Language:  C++
  Date:      $Date: 2009-05-19 15:45:39 +0200 (Di, 19 Mai 2009) $
  Version:   $Revision: 17020 $
 
  Copyright (c) German Cancer Research Center, Division of Medical and
  Biological Informatics. All rights reserved.
  See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.  See the above copyright notices for more information.
 
  =========================================================================*/
 
 
 #ifndef MITKDIFFUSIONIMAGINGACTIVATOR_H_ 
 #define MITKDIFFUSIONIMAGINGACTIVATOR_H_ 
 
-#include <berryPlugin.h>
-
-#include <mitkDiffusionImagingDll.h>
-
-//#include <QSlider>
-//#include <QObject>
+#include <ctkPluginActivator.h>
 
 namespace mitk
 {
 
 /**
  * \ingroup org_mitk_diffusionimaging_internal
  *
  * \brief The plug-in activator for the diffusion imaging module
  *
- * When the plug-in is started by the framework, it initialzes sandbox
+ * When the plug-in is started by the framework, it initialzes diffusion imaging
  * specific things.
  */
-class ORG_MITK_DIFFUSIONIMAGING_EXPORT DiffusionImagingActivator : 
-  /*public QObject, */public berry::Plugin
+class DiffusionImagingActivator : 
+  public QObject, public ctkPluginActivator
 {
 
-  //Q_OBJECT
+  Q_OBJECT
+  Q_INTERFACES(ctkPluginActivator)
 
 public:
 
   /**
-   * Registers sandbox core object factories.
+   * Registers diffusion imaging object factories.
    */
-  void Start(berry::IBundleContext::Pointer context);
-
-  //void OpactiyChanged(int value);
-  //void OpactiyActionChanged();
-
-  //void CreateQtPartControl(QWidget *){}
-
-private:
-
-  //QSlider* m_OpacitySlider;
+  void start(ctkPluginContext* context);
+  
+  void stop(ctkPluginContext* context);
 
 };
 
 }
 #endif /* MITKDIFFUSIONIMAGINGACTIVATOR_H_ */
diff --git a/Modules/Bundles/org.mitk.diffusionimaging/src/mitkDiffusionImagingDll.h b/Modules/Bundles/org.mitk.diffusionimaging/src/mitkDiffusionImagingDll.h
deleted file mode 100644
index eae734f38d..0000000000
--- a/Modules/Bundles/org.mitk.diffusionimaging/src/mitkDiffusionImagingDll.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*=========================================================================
-
-Program:   Medical Imaging & Interaction Toolkit
-Language:  C++
-Date:      $Date: 2009-05-28 20:03:37 +0200 (Do, 28 Mai 2009) $
-Version:   $Revision: 17020 $
-
-Copyright (c) German Cancer Research Center, Division of Medical and
-Biological Informatics. All rights reserved.
-See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
-
-This software is distributed WITHOUT ANY WARRANTY; without even
-the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
-
-#ifndef _MBI_MITKDIFFUSIONIMAGING_EXPORT_DLL_H_
-#define _MBI_MITKDIFFUSIONIMAGING_EXPORT_DLL_H_
-
-
-//
-// The following block is the standard way of creating macros which make exporting
-// from a DLL simpler. All files within this DLL are compiled with the org_mitk_diffusionimaging_EXPORTS
-// symbol defined on the command line. this symbol should not be defined on any project
-// that uses this DLL. This way any other project whose source files include this file see
-// org_mitk_diffusionimaging_EXPORTS functions as being imported from a DLL, wheras this DLL sees symbols
-// defined with this macro as being exported.
-//
-#if defined(_WIN32) && !defined(MITK_STATIC)
-  #if defined(org_mitk_diffusionimaging_EXPORTS)
-    #define ORG_MITK_DIFFUSIONIMAGING_EXPORT __declspec(dllexport)
-  #else
-    #define ORG_MITK_DIFFUSIONIMAGING_EXPORT __declspec(dllimport)
-  #endif
-#endif
-
-
-#if !defined(ORG_MITK_DIFFUSIONIMAGING_EXPORT)
-  #define ORG_MITK_DIFFUSIONIMAGING_EXPORT
-#endif
-
-#endif /*_MBI_MITKDIFFUSIONIMAGING_EXPORT_DLL_H_*/
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/CMakeLists.txt b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/CMakeLists.txt
index 7c74b94876..775263d718 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/CMakeLists.txt
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/CMakeLists.txt
@@ -1,2 +1,7 @@
-INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR})
-MACRO_CREATE_MITK_PLUGIN(QmitkExt MitkDiffusionImaging)
+PROJECT(org_mitk_gui_qt_diffusionimaging)
+
+MACRO_CREATE_MITK_CTK_PLUGIN(
+  EXPORT_DIRECTIVE DIFFUSIONIMAGING_EXPORT
+  EXPORTED_INCLUDE_SUFFIXES src
+  MODULE_DEPENDENCIES QmitkExt MitkDiffusionImaging
+)
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/META-INF/MANIFEST.MF b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/META-INF/MANIFEST.MF
deleted file mode 100644
index 98b71130e6..0000000000
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,7 +0,0 @@
-Manifest-Version: 1.0
-Bundle-Name: Diffusion Imaging 
-Bundle-SymbolicName: org.mitk.gui.qt.diffusionimaging 
-Bundle-Version: 0.1
-Bundle-Vendor: DKFZ, Medical and Biological Informatics
-Require-Bundle: org.mitk.gui.qt.common, org.mitk.diffusionimaging
-Bundle-Activator: 
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/files.cmake b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/files.cmake
index e14d168c1e..213a109ef8 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/files.cmake
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/files.cmake
@@ -1,74 +1,65 @@
 SET(SRC_CPP_FILES
   
 )
 
 SET(INTERNAL_CPP_FILES
+  mitkPluginActivator.cpp
   QmitkQBallReconstructionView.cpp
   QmitkPreprocessingView.cpp
   QmitkDiffusionDicomImportView.cpp
   QmitkDiffusionQuantificationView.cpp
   QmitkTensorReconstructionView.cpp
   QmitkDiffusionImagingPublicPerspective.cpp
   QmitkControlVisualizationPropertiesView.cpp  
 )
 
 SET(UI_FILES
   src/internal/QmitkQBallReconstructionViewControls.ui
   src/internal/QmitkPreprocessingViewControls.ui
   src/internal/QmitkDiffusionDicomImportViewControls.ui
   src/internal/QmitkDiffusionQuantificationViewControls.ui
   src/internal/QmitkTensorReconstructionViewControls.ui
   src/internal/QmitkControlVisualizationPropertiesViewControls.ui  
 )
 
 SET(MOC_H_FILES
+  src/internal/mitkPluginActivator.h
   src/internal/QmitkQBallReconstructionView.h
   src/internal/QmitkPreprocessingView.h
   src/internal/QmitkDiffusionDicomImportView.h
+  src/internal/QmitkDiffusionImagingPublicPerspective.h
   src/internal/QmitkDiffusionQuantificationView.h
   src/internal/QmitkTensorReconstructionView.h
   src/internal/QmitkControlVisualizationPropertiesView.h  
 )
 
-SET(RESOURCE_FILES
+SET(CACHED_RESOURCE_FILES
 # list of resource files which can be used by the plug-in
 # system without loading the plug-ins shared library,
 # for example the icon used in the menu and tabs for the
 # plug-in views in the workbench
-  resources/dwi.png
-  resources/tensor.png
-  resources/qball.png
+  plugin.xml
+
   resources/preprocessing.png
   resources/dwiimport.png
   resources/quantification.png
   resources/reconodf.png
   resources/recontensor.png
-  resources/stats.png
-  resources/texIntOFFIcon.png
-  resources/texIntONIcon.png
   resources/vizControls.png
-  resources/Refresh_48.png
-  resources/QBallData24.png
-  resources/glyphsoff_C.png
-  resources/glyphsoff_S.png
-  resources/glyphsoff_T.png
-  resources/glyphson_C.png
-  resources/glyphson_S.png
-  resources/glyphson_T.png
 )
 
-SET(RES_FILES
+SET(QRC_FILES
 # uncomment the following line if you want to use Qt resources
   resources/QmitkDiffusionImaging.qrc
 )
 
-SET(CPP_FILES manifest.cpp)
+SET(CPP_FILES )
 
 foreach(file ${SRC_CPP_FILES})
   SET(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   SET(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
 
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/manifest.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/manifest.cpp
deleted file mode 100644
index 4dcc09b83f..0000000000
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/manifest.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*=========================================================================
-
-Program:   Medical Imaging & Interaction Toolkit
-Module:    $RCSfile$
-Language:  C++
-Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
-Version:   $Revision: 17495 $ 
- 
-Copyright (c) German Cancer Research Center, Division of Medical and
-Biological Informatics. All rights reserved.
-See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
-
-This software is distributed WITHOUT ANY WARRANTY; without even
-the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
-
-#include <Poco/ClassLibrary.h>
-
-#include "src/internal/QmitkQBallReconstructionView.h"
-#include "src/internal/QmitkPreprocessingView.h"
-#include "src/internal/QmitkDiffusionDicomImportView.h"
-#include "src/internal/QmitkDiffusionQuantificationView.h"
-#include "src/internal/QmitkTensorReconstructionView.h"
-#include "src/internal/QmitkControlVisualizationPropertiesView.h"
-//#include "src/internal/QmitkTbssView.h"
-#include "src/internal/QmitkDiffusionImagingPublicPerspective.h"
-
-POCO_BEGIN_NAMED_MANIFEST(berryIPerspectiveFactory, berry::IPerspectiveFactory)
-  POCO_EXPORT_CLASS(QmitkDiffusionImagingPublicPerspective)
-POCO_END_MANIFEST
-
-POCO_BEGIN_NAMED_MANIFEST(berryIViewPart, berry::IViewPart)
-  POCO_EXPORT_CLASS(QmitkQBallReconstructionView)
-  POCO_EXPORT_CLASS(QmitkPreprocessingView)
-  POCO_EXPORT_CLASS(QmitkDiffusionDicomImport)
-  POCO_EXPORT_CLASS(QmitkDiffusionQuantificationView)
-  POCO_EXPORT_CLASS(QmitkTensorReconstructionView)
-  POCO_EXPORT_CLASS(QmitkControlVisualizationPropertiesView)
-  //POCO_EXPORT_CLASS(QmitkTbssView)
-POCO_END_MANIFEST
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/manifest_headers.cmake b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/manifest_headers.cmake
new file mode 100644
index 0000000000..5b8b79e4a1
--- /dev/null
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/manifest_headers.cmake
@@ -0,0 +1,5 @@
+set(Plugin-Name "Diffusion Imaging")
+set(Plugin-Version "0.1")
+set(Plugin-Vendor "DKFZ, Medical and Biological Informatics")
+set(Plugin-ContactAddress "http://www.mitk.org")
+set(Require-Plugin org.mitk.gui.qt.common org.mitk.diffusionimaging)
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/DiffusionimagingDll.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/DiffusionimagingDll.h
deleted file mode 100644
index 1d59e0f889..0000000000
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/DiffusionimagingDll.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*=========================================================================
-
-Program:   Medical Imaging & Interaction Toolkit
-Module:    $RCSfile$
-Language:  C++
-Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
-Version:   $Revision: 17495 $ 
- 
-Copyright (c) German Cancer Research Center, Division of Medical and
-Biological Informatics. All rights reserved.
-See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
-
-This software is distributed WITHOUT ANY WARRANTY; without even
-the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
-
-#ifndef _DIFFUSIONIMAGING_EXPORT_DLL_H_
-#define _DIFFUSIONIMAGING_EXPORT_DLL_H_
-
-
-//
-// The following block is the standard way of creating macros which make exporting
-// from a DLL simpler. All files within this DLL are compiled with the org_mitk_gui_qt_diffusionimaging_EXPORTS
-// symbol defined on the command line. this symbol should not be defined on any project
-// that uses this DLL. This way any other project whose source files include this file see
-// org_mitk_gui_qt_diffusionimaging_EXPORTS functions as being imported from a DLL, wheras this DLL sees symbols
-// defined with this macro as being exported.
-//
-#if defined(_WIN32) && !defined(MITK_STATIC)
-  #if defined(org_mitk_gui_qt_diffusionimaging_EXPORTS)
-    #define DIFFUSIONIMAGING_EXPORT __declspec(dllexport)
-  #else
-    #define DIFFUSIONIMAGING_EXPORT __declspec(dllimport)
-  #endif
-#endif
-
-
-#if !defined(DIFFUSIONIMAGING_EXPORT)
-  #define DIFFUSIONIMAGING_EXPORT
-#endif
-
-#endif /*_DIFFUSIONIMAGING_EXPORT_DLL_H_*/
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index e485783c92..2dc89658e7 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,876 +1,882 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkControlVisualizationPropertiesView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 
 #include "mitkDiffusionImage.h"
 
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 
 const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
 
 using namespace berry;
 
 struct CvpSelListener : ISelectionListener
 {
 
   berryObjectMacro(CvpSelListener);
 
   CvpSelListener(QmitkControlVisualizationPropertiesView* view)
   {
     m_View = view;
   }
 
   void ApplySettings(mitk::DataNode::Pointer node)
   {
     bool do_vis;
     node->GetBoolProperty("VisibleOdfs_T", do_vis);
     if(do_vis)
     {
       m_View->m_Controls->m_VisibleOdfsON_T->setIcon(*m_View->m_IconGlyON_T);
       m_View->m_Controls->m_VisibleOdfsON_T->setChecked(true);
       m_View->m_GlyIsOn_T = true;
     }
     else
     {
       m_View->m_Controls->m_VisibleOdfsON_T->setIcon(*m_View->m_IconGlyOFF_T);
       m_View->m_Controls->m_VisibleOdfsON_T->setChecked(false);
       m_View->m_GlyIsOn_T = false;
     }
 
     node->GetBoolProperty("VisibleOdfs_C", do_vis);
     if(do_vis)
     {
       m_View->m_Controls->m_VisibleOdfsON_C->setIcon(*m_View->m_IconGlyON_C);
       m_View->m_Controls->m_VisibleOdfsON_C->setChecked(true);
       m_View->m_GlyIsOn_C = true;
     }
     else
     {
       m_View->m_Controls->m_VisibleOdfsON_C->setIcon(*m_View->m_IconGlyOFF_C);
       m_View->m_Controls->m_VisibleOdfsON_C->setChecked(false);
       m_View->m_GlyIsOn_C = false;
     }
 
     node->GetBoolProperty("VisibleOdfs_S", do_vis);
     if(do_vis)
     {
       m_View->m_Controls->m_VisibleOdfsON_S->setIcon(*m_View->m_IconGlyON_S);
       m_View->m_Controls->m_VisibleOdfsON_S->setChecked(true);
       m_View->m_GlyIsOn_S = true;
     }
     else
     {
       m_View->m_Controls->m_VisibleOdfsON_S->setIcon(*m_View->m_IconGlyOFF_S);
       m_View->m_Controls->m_VisibleOdfsON_S->setChecked(false);
       m_View->m_GlyIsOn_S = false;
     }
 
     bool tex_int;
     node->GetBoolProperty("texture interpolation", tex_int);
     if(tex_int)
     {
       m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
       m_View->m_Controls->m_TextureIntON->setChecked(true);
       m_View->m_TexIsOn = true;
     }
     else
     {
       m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
       m_View->m_Controls->m_TextureIntON->setChecked(false);
       m_View->m_TexIsOn = false;
     }
 
     int val;
     node->GetIntProperty("ShowMaxNumber", val);
     m_View->m_Controls->m_ShowMaxNumber->setValue(val);
 
     m_View->m_Controls->m_NormalizationDropdown->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))->GetValueAsId());
 
     float fval;
     node->GetFloatProperty("Scaling",fval);
     m_View->m_Controls->m_ScalingFactor->setValue(fval);
 
     m_View->m_Controls->m_AdditionalScaling->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
 
     node->GetFloatProperty("IndexParam1",fval);
     m_View->m_Controls->m_IndexParam1->setValue(fval);
 
     node->GetFloatProperty("IndexParam2",fval);
     m_View->m_Controls->m_IndexParam2->setValue(fval);
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
     // save current selection in member variable
     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
 
     m_View->m_Controls->m_VisibleOdfsON_T->setVisible(false);
     m_View->m_Controls->m_VisibleOdfsON_S->setVisible(false);
     m_View->m_Controls->m_VisibleOdfsON_C->setVisible(false);
     m_View->m_Controls->m_TextureIntON->setVisible(false);
 
     bool foundDiffusionImage = false;
     bool foundQBIVolume = false;
     bool foundTensorVolume = false;
     bool foundImage = false;
     bool foundMultipleOdfImages = false;
     bool foundRGBAImage = false;
 
     // do something with the selected items
     if(m_View->m_CurrentSelection)
     {
       // 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();
 
           // only look at interesting types
           if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
           {
             foundDiffusionImage = true;
             bool tex_int;
             node->GetBoolProperty("texture interpolation", tex_int);
             if(tex_int)
             {
               m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
               m_View->m_Controls->m_TextureIntON->setChecked(true);
               m_View->m_TexIsOn = true;
             }
             else
             {
               m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
               m_View->m_Controls->m_TextureIntON->setChecked(false);
               m_View->m_TexIsOn = false;
             }
             int val;
             node->GetIntProperty("DisplayChannel", val);
             m_View->m_Controls->m_DisplayIndex->setValue(val);
 
             QString label = "Channel %1";
             label = label.arg(val);
             m_View->m_Controls->label_channel->setText(label);
 
             int maxVal = (dynamic_cast<mitk::DiffusionImage<short>* >(node->GetData()))->GetVectorImage()->GetVectorLength();
             m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
           }
 
           else if(QString("QBallImage").compare(node->GetData()->GetNameOfClass())==0)
           {
             foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
             foundQBIVolume = true;
             ApplySettings(node);
           }
 
           else if(QString("TensorImage").compare(node->GetData()->GetNameOfClass())==0)
           {
             foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
             foundTensorVolume = true;
             ApplySettings(node);
           }
 
           else if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
           {
             foundImage = true;
             mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(node->GetData());
             if(img.IsNotNull() && img->GetPixelType().GetItkTypeId() == &typeid(itk::RGBAPixel<unsigned char>) )
             {
               foundRGBAImage = true;
             }
 
             bool tex_int;
             node->GetBoolProperty("texture interpolation", tex_int);
             if(tex_int)
             {
               m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
               m_View->m_Controls->m_TextureIntON->setChecked(true);
               m_View->m_TexIsOn = true;
             }
             else
             {
               m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
               m_View->m_Controls->m_TextureIntON->setChecked(false);
               m_View->m_TexIsOn = false;
             }
           }
         }
       }
     }
 
     m_View->m_Controls->m_DisplayIndex->setVisible(foundDiffusionImage);
     m_View->m_Controls->label_channel->setVisible(foundDiffusionImage);
 
     m_View->m_FoundSingleOdfImage = (foundQBIVolume || foundTensorVolume)
                                     && !foundMultipleOdfImages;
     m_View->m_Controls->m_NumberGlyphsFrame->setVisible(m_View->m_FoundSingleOdfImage);
 
     m_View->m_Controls->m_NormalizationDropdown->setVisible(m_View->m_FoundSingleOdfImage);
     m_View->m_Controls->label->setVisible(m_View->m_FoundSingleOdfImage);
     m_View->m_Controls->m_ScalingFactor->setVisible(m_View->m_FoundSingleOdfImage);
     m_View->m_Controls->m_AdditionalScaling->setVisible(m_View->m_FoundSingleOdfImage);
     m_View->m_Controls->m_NormalizationScalingFrame->setVisible(m_View->m_FoundSingleOdfImage);
 
     m_View->m_Controls->OpacMinFrame->setVisible(foundRGBAImage || m_View->m_FoundSingleOdfImage);
 
     // changed for SPIE paper, Principle curvature scaling
     //m_View->m_Controls->params_frame->setVisible(m_View->m_FoundSingleOdfImage);
     m_View->m_Controls->params_frame->setVisible(false);
 
     m_View->m_Controls->m_VisibleOdfsON_T->setVisible(m_View->m_FoundSingleOdfImage);
     m_View->m_Controls->m_VisibleOdfsON_S->setVisible(m_View->m_FoundSingleOdfImage);
     m_View->m_Controls->m_VisibleOdfsON_C->setVisible(m_View->m_FoundSingleOdfImage);
 
     bool foundAnyImage = foundDiffusionImage ||
                          foundQBIVolume || foundTensorVolume || foundImage;
 
     m_View->m_Controls->m_Reinit->setVisible(foundAnyImage);
     m_View->m_Controls->m_TextureIntON->setVisible(foundAnyImage);
 
     if(m_View->m_IsInitialized)
     {
       //m_View->GetSite()->GetWorkbenchWindow()->GetActivePage()
       //  ->HideView(IViewPart::Pointer(m_View));
 
       //berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()
       //  ->ShowView(QmitkControlVisualizationPropertiesView::VIEW_ID,
       //  "", berry::IWorkbenchPage::VIEW_VISIBLE);
 
     }
   }
 
   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);
 
       }
     }
   }
 
   QmitkControlVisualizationPropertiesView* m_View;
 };
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView()
   : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL),
   m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")),
   m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")),
   m_IconGlyOFF_T(new QIcon(":/QmitkDiffusionImaging/glyphsoff_T.png")),
   m_IconGlyON_T(new QIcon(":/QmitkDiffusionImaging/glyphson_T.png")),
   m_IconGlyOFF_C(new QIcon(":/QmitkDiffusionImaging/glyphsoff_C.png")),
   m_IconGlyON_C(new QIcon(":/QmitkDiffusionImaging/glyphson_C.png")),
   m_IconGlyOFF_S(new QIcon(":/QmitkDiffusionImaging/glyphsoff_S.png")),
   m_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png"))
 {
 }
 
+QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView(const QmitkControlVisualizationPropertiesView& other)
+{
+  Q_UNUSED(other)
+  throw std::runtime_error("Copy constructor not implemented");
+}
+
 QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->params_frame->setVisible(false);
 
     QIcon icon5(":/QmitkDiffusionImaging/Refresh_48.png");
     m_Controls->m_Reinit->setIcon(icon5);
 
     m_Controls->m_TextureIntON->setCheckable(true);
     m_Controls->m_VisibleOdfsON_T->setCheckable(true);
     m_Controls->m_VisibleOdfsON_S->setCheckable(true);
     m_Controls->m_VisibleOdfsON_C->setCheckable(true);
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     int size = m_Controls->m_AdditionalScaling->count();
     for(int t=0; t<size; t++)
     {
       if(m_Controls->m_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR")
       {
         m_Controls->m_AdditionalScaling->removeItem(t);
       }
     }
 #endif
 
     m_Controls->m_OpacitySlider->setRange(0.0,1.0);
     m_Controls->m_OpacitySlider->setLowerValue(0.0);
     m_Controls->m_OpacitySlider->setUpperValue(0.0);
 
     m_Controls->m_ScalingFrame->setVisible(false);
     m_Controls->m_NormalizationFrame->setVisible(false);
 
   }
 
   
 
   m_IsInitialized = false;
   m_SelListener = berry::ISelectionListener::Pointer(new CvpSelListener(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<CvpSelListener>()->DoSelectionChanged(sel);
   m_IsInitialized = true;
 }
 
 void QmitkControlVisualizationPropertiesView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkControlVisualizationPropertiesView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkControlVisualizationPropertiesView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_DisplayIndex), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
     connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
     connect( (QObject*)(m_Controls->m_Reinit), SIGNAL(clicked()), this, SLOT(Reinit()) );
 
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_T), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_T()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_S), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_S()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_C), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_C()) );
 
     connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) );
     connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) );
     connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) );
     connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) );
     connect( (QObject*)(m_Controls->m_IndexParam1), SIGNAL(valueChanged(double)), this, SLOT(IndexParam1Changed(double)) );
     connect( (QObject*)(m_Controls->m_IndexParam2), SIGNAL(valueChanged(double)), this, SLOT(IndexParam2Changed(double)) );
 
     connect( (QObject*)(m_Controls->m_NormalizationCheckbox), SIGNAL(clicked()), this, SLOT(NormalizationCheckbox()) );
     connect( (QObject*)(m_Controls->m_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
 
     connect( (QObject*)(m_Controls->m_OpacitySlider), SIGNAL(spanChanged(double,double)), this, SLOT(OpacityChanged(double,double)) );
 
   }
 }
 
 void QmitkControlVisualizationPropertiesView::Activated()
 {
   berry::ISelection::ConstPointer sel(
       this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
   QmitkFunctionality::Activated();
 }
 
 void QmitkControlVisualizationPropertiesView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 int QmitkControlVisualizationPropertiesView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkControlVisualizationPropertiesView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return m_FoundSingleOdfImage ? 120 : 80;
   }
   else
   {
     return preferredResult;
   }
 }
 
 mitk::DataStorage::SetOfObjects::Pointer
     QmitkControlVisualizationPropertiesView::ActiveSet(std::string classname)
 {
   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(classname.c_str()).compare(node->GetData()->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     return set;
   }
 
   return 0;
 }
 
 void QmitkControlVisualizationPropertiesView::SetBoolProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, bool value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetBoolProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetIntProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, int value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetFloatProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, float value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetFloatProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetLevelWindowProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, mitk::LevelWindow value)
 {
   if(set.IsNotNull())
   {
 
     mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), prop);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetEnumProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, mitk::EnumerationProperty::Pointer value)
 {
   if(set.IsNotNull())
   {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::DisplayIndexChanged(int dispIndex)
 {
 
   QString label = "Channel %1";
   label = label.arg(dispIndex);
   m_Controls->label_channel->setText(label);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("DiffusionImage");
 
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
       ++itemiter;
     }
 
     //m_MultiWidget->RequestUpdate();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::Reinit()
 {
   if (m_CurrentSelection)
   {
     mitk::DataNodeObject::Pointer nodeObj = 
         m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
     mitk::DataNode::Pointer node = nodeObj->GetDataNode();
     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();
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::TextIntON()
 {
   if(m_TexIsOn)
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
   }
   else
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("DiffusionImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("QBallImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("Image");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   m_TexIsOn = !m_TexIsOn;
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_S()
 {
   if(m_GlyIsOn_S)
   {
     m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyOFF_S);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyON_S);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
 
   m_GlyIsOn_S = !m_GlyIsOn_S;
 
    VisibleOdfsON(0);
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T()
 {
   if(m_GlyIsOn_T)
   {
     m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyOFF_T);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyON_T);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
 
   m_GlyIsOn_T = !m_GlyIsOn_T;
 
   VisibleOdfsON(1);
 
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C()
 {
   if(m_GlyIsOn_C)
   {
     m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyOFF_C);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyON_C);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
 
   m_GlyIsOn_C = !m_GlyIsOn_C;
 
   VisibleOdfsON(2);
 
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON(int view)
 {
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
 {
   int maxNr = m_Controls->m_ShowMaxNumber->value();
   if ( maxNr < 1 )
   {
     m_Controls->m_ShowMaxNumber->setValue( 1 );
     maxNr = 1;
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   set = ActiveSet("TensorImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown)
 {
   typedef mitk::OdfNormalizationMethodProperty PropType;
   PropType::Pointer normMeth = PropType::New();
 
   switch(normDropdown)
   {
   case 0:
     normMeth->SetNormalizationToMinMax();
     break;
   case 1:
     normMeth->SetNormalizationToMax();
     break;
   case 2:
     normMeth->SetNormalizationToNone();
     break;
   case 3:
     normMeth->SetNormalizationToGlobalMax();
     break;
   default:
     normMeth->SetNormalizationToMinMax();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
 {
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling)
 {
 
   typedef mitk::OdfScaleByProperty PropType;
   PropType::Pointer scaleBy = PropType::New();
 
   switch(additionalScaling)
   {
   case 0:
     scaleBy->SetScaleByNothing();
     break;
   case 1:
     scaleBy->SetScaleByGFA();
     //m_Controls->params_frame->setVisible(true);
     break;
 #ifdef DIFFUSION_IMAGING_EXTENDED
   case 2:
     scaleBy->SetScaleByPrincipalCurvature();
     // commented in for SPIE paper, Principle curvature scaling
     //m_Controls->params_frame->setVisible(true);
     break;
 #endif
   default:
     scaleBy->SetScaleByNothing();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::IndexParam1Changed(double param1)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkControlVisualizationPropertiesView::IndexParam2Changed(double param2)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkControlVisualizationPropertiesView::OpacityChanged(double l, double u)
 {
   mitk::LevelWindow olw;
   olw.SetRangeMinMax(l*255, u*255);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("TensorImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("Image");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::NormalizationCheckbox()
 {
   m_Controls->m_NormalizationFrame->setVisible(
       m_Controls->m_NormalizationCheckbox->isChecked());
 }
 
 void QmitkControlVisualizationPropertiesView::ScalingCheckbox()
 {
   m_Controls->m_ScalingFrame->setVisible(
       m_Controls->m_ScalingCheckbox->isChecked());
 }
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h
index e65fa576de..7513535175 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h
@@ -1,135 +1,136 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef _QMITKControlVisualizationPropertiesView_H_INCLUDED
 #define _QMITKControlVisualizationPropertiesView_H_INCLUDED
 
 #include <QmitkFunctionality.h>
 
 #include <string>
 
 #include "berryISelectionListener.h"
 #include "berryIStructuredSelection.h"
 #include "berryISizeProvider.h"
 
 #include "ui_QmitkControlVisualizationPropertiesViewControls.h"
 
 #include "mitkEnumerationProperty.h"
 
 /*!
  * \ingroup org_mitk_gui_qt_diffusionquantification_internal
  *
  * \brief QmitkControlVisualizationPropertiesView
  *
  * Document your class here.
  *
  * \sa QmitkFunctionality
  */
-class QmitkControlVisualizationPropertiesView : public QObject, public QmitkFunctionality//, public berry::ISizeProvider
+class QmitkControlVisualizationPropertiesView : public QmitkFunctionality//, public berry::ISizeProvider
 {
 
   friend struct CvpSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   QmitkControlVisualizationPropertiesView();
+  QmitkControlVisualizationPropertiesView(const QmitkControlVisualizationPropertiesView& other);
   virtual ~QmitkControlVisualizationPropertiesView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
   /// \brief Called when the functionality is activated
   virtual void Activated();
 
   virtual void Deactivated();
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   mitk::DataStorage::SetOfObjects::Pointer ActiveSet(std::string);
 
   void SetBoolProp (mitk::DataStorage::SetOfObjects::Pointer,std::string,bool);
   void SetIntProp  (mitk::DataStorage::SetOfObjects::Pointer,std::string,int);
   void SetFloatProp(mitk::DataStorage::SetOfObjects::Pointer,std::string,float);
   void SetLevelWindowProp(mitk::DataStorage::SetOfObjects::Pointer,std::string,mitk::LevelWindow);
   void SetEnumProp (mitk::DataStorage::SetOfObjects::Pointer,std::string,mitk::EnumerationProperty::Pointer);
 
   virtual int GetSizeFlags(bool width);
   virtual int ComputePreferredSize(bool width, int availableParallel, int availablePerpendicular, int preferredResult);
 
 protected slots:
 
   void DisplayIndexChanged(int);
   void TextIntON();
   void Reinit();
 
   void VisibleOdfsON(int view);
   void VisibleOdfsON_S();
   void VisibleOdfsON_T();
   void VisibleOdfsON_C();
 
   void ShowMaxNumberChanged();
   void NormalizationDropdownChanged(int);
   void ScalingFactorChanged(double);
   void AdditionalScaling(int);
   void IndexParam1Changed(double);
   void IndexParam2Changed(double);
   void OpacityChanged(double,double);
   void NormalizationCheckbox();
   void ScalingCheckbox();
 
 protected:
 
   Ui::QmitkControlVisualizationPropertiesViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
   berry::ISelectionListener::Pointer m_SelListener;
   berry::IStructuredSelection::ConstPointer m_CurrentSelection;
 
   bool m_FoundSingleOdfImage;
   bool m_IsInitialized;
 
   QIcon* m_IconTexOFF;
   QIcon* m_IconTexON;
   QIcon* m_IconGlyOFF_T;
   QIcon* m_IconGlyON_T;
   QIcon* m_IconGlyOFF_C;
   QIcon* m_IconGlyON_C;
   QIcon* m_IconGlyOFF_S;
   QIcon* m_IconGlyON_S;
 
   bool m_TexIsOn;
   bool m_GlyIsOn_T;
   bool m_GlyIsOn_C;
   bool m_GlyIsOn_S;
 
 };
 
 
 
 
 #endif // _QMITKControlVisualizationPropertiesView_H_INCLUDED
 
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
index 967cc5ed80..732618f934 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
@@ -1,672 +1,678 @@
 /*=========================================================================
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkDiffusionDicomImportView.h"
 
 // qt includes
 #include <QFileDialog>
 
 // itk includes
 #include "itkTimeProbesCollectorBase.h"
 #include "itkGDCMSeriesFileNames.h"
 #include "itksys/SystemTools.hxx"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkMemoryUtilities.h"
 
 // diffusion module includes
 #include "mitkDicomDiffusionImageHeaderReader.h"
 #include "mitkGroupDiffusionHeadersFilter.h"
 #include "mitkDicomDiffusionImageReader.h"
 #include "mitkDiffusionImage.h"
 #include "mitkNrrdDiffusionImageWriter.h"
 
 #if  GDCM_MAJOR_VERSION >= 2
 #define DGDCM2
 #endif
 
 #ifdef DGDCM2
 #include "gdcmDirectory.h"
 #include "gdcmScanner.h"
 #include "gdcmSorter.h"
 #include "gdcmIPPSorter.h"
 #include "gdcmAttribute.h"
 #include "gdcmVersion.h"
 #endif
 
 const std::string QmitkDiffusionDicomImport::VIEW_ID = "org.mitk.views.diffusiondicomimport";
 
 
 QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(QObject* /*parent*/, const char* /*name*/)
   : QmitkFunctionality(), m_Controls(NULL), m_MultiWidget(NULL),
   m_OutputFolderName(""), m_OutputFolderNameSet(false)
 {
 }
 
+QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(const QmitkDiffusionDicomImport& other)
+{
+  Q_UNUSED(other)
+  throw std::runtime_error("Copy constructor not implemented");
+}
+
 QmitkDiffusionDicomImport::~QmitkDiffusionDicomImport()
 {}
 
 void QmitkDiffusionDicomImport::CreateQtPartControl(QWidget *parent)
 {
   m_Parent = parent;
   if (m_Controls == NULL)
   {
     m_Controls = new Ui::QmitkDiffusionDicomImportControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_DicomLoadRecursiveCheckbox->setChecked(true);
     m_Controls->m_DicomLoadAverageDuplicatesCheckbox->setChecked(false);
 
 #ifdef DGDCM2
     m_Controls->m_DicomLoadRecursiveCheckbox->setVisible(false);
 #endif
 
     AverageClicked();
   }
 }
 
 
 
 void QmitkDiffusionDicomImport::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( m_Controls->m_AddFoldersButton, SIGNAL(clicked()), 
              this, SLOT(DicomLoadAddFolderNames()) );
     connect( m_Controls->m_DeleteFoldersButton, SIGNAL(clicked()), 
              this, SLOT(DicomLoadDeleteFolderNames()) );
     connect( m_Controls->m_DicomLoadStartLoadButton, SIGNAL(clicked()), 
              this, SLOT(DicomLoadStartLoad()) );
     connect( m_Controls->m_DicomLoadAverageDuplicatesCheckbox, SIGNAL(clicked()),
              this, SLOT(AverageClicked()) );
     connect( m_Controls->m_OutputSetButton, SIGNAL(clicked()),
              this, SLOT(OutputSet()) );
     connect( m_Controls->m_OutputClearButton, SIGNAL(clicked()),
              this, SLOT(OutputClear()) );
   }
 }
 
 
 void QmitkDiffusionDicomImport::OutputSet()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_OutputFolderName = w->selectedFiles()[0];
   m_OutputFolderNameSet = true;
   m_Controls->m_OutputLabel->setText(m_OutputFolderName);
 }
 
 void QmitkDiffusionDicomImport::OutputClear()
 {
   m_OutputFolderName = "";
   m_OutputFolderNameSet = false;
   m_Controls->m_OutputLabel->setText("... optional out-folder ...");
 }
 
 void QmitkDiffusionDicomImport::AverageClicked()
 {
   m_Controls->m_Blur->setEnabled(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked());
 }
 
 void QmitkDiffusionDicomImport::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkDiffusionDicomImport::DicomLoadDeleteFolderNames() 
 {
   m_Controls->listWidget->clear();
 }
 
 void QmitkDiffusionDicomImport::DicomLoadAddFolderNames() 
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_Controls->listWidget->addItems(w->selectedFiles());
 }
 
 #ifdef DGDCM2
 bool SortBySeriesUID(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0020,0x000e> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0020,0x000e> at2;
   at2.Set( ds2 );
   return at1 < at2;
 }
 
 bool SortByAcquisitionNumber(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0020,0x0012> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0020,0x0012> at2;
   at2.Set( ds2 );
   return at1 < at2;
 }
 
 bool SortBySeqName(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0018, 0x0024> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0018, 0x0024> at2;
   at2.Set( ds2 );
 
   std::string str1 = at1.GetValue(0).Trim();
   std::string str2 = at2.GetValue(0).Trim();
   return std::lexicographical_compare(str1.begin(), str1.end(),
                                       str2.begin(), str2.end() );
 }
 #endif
 
 void QmitkDiffusionDicomImport::Status(QString status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status.toAscii());
   MITK_INFO << status.toStdString().c_str();
 }
 
 void QmitkDiffusionDicomImport::Status(std::string status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status.c_str());
   MITK_INFO << status.c_str();
 }
 
 void QmitkDiffusionDicomImport::Status(const char* status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status);
   MITK_INFO << status;
 }
 
 void QmitkDiffusionDicomImport::Error(QString status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status.toAscii());
   MITK_ERROR << status.toStdString().c_str();
 }
 
 void QmitkDiffusionDicomImport::Error(std::string status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status.c_str());
   MITK_ERROR << status.c_str();
 }
 
 void QmitkDiffusionDicomImport::Error(const char* status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status);
   MITK_ERROR << status;
 }
 
 void QmitkDiffusionDicomImport::PrintMemoryUsage()
 {
   size_t processSize = mitk::MemoryUtilities::GetProcessMemoryUsage();
   size_t totalSize =  mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
   float percentage = ( (float) processSize / (float) totalSize ) * 100.0;
   MITK_INFO << "Current memory usage: " << GetMemoryDescription( processSize, percentage );
 }
 
 std::string QmitkDiffusionDicomImport::FormatMemorySize( size_t size )
 {
   double val = size;
   std::string descriptor("B");
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "KB";
   }
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "MB";
   }
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "GB";
   }
   std::ostringstream str;
   str << std::fixed << std::setprecision(2) << val << " " << descriptor;
   return str.str();
 }
 
 std::string QmitkDiffusionDicomImport::FormatPercentage( double val )
 {
   std::ostringstream str;
   str << std::fixed << std::setprecision(2) << val << " " << "%";
   return str.str();
 }
 
 std::string QmitkDiffusionDicomImport::GetMemoryDescription( size_t processSize, float percentage )
 {
   std::ostringstream str;
   str << FormatMemorySize(processSize) << " (" << FormatPercentage( percentage ) <<")" ;
   return str.str();
 }
 
 void QmitkDiffusionDicomImport::DicomLoadStartLoad() 
 {
   itk::TimeProbesCollectorBase clock;
 
   try
   {
 
     int nrFolders = m_Controls->listWidget->count();
 
     if(!nrFolders)
     {
       Error(QString("No input folders were selected. ABORTING."));
       return;
     }
 
 #ifndef DGDCM2
     Status(QString("GDCM 1.x used for DICOM parsing and sorting!"));
 #else
     Status(QString("GDCM %1 used for DICOM parsing and sorting!").arg(gdcm::Version::GetVersion()));
 #endif
 
     PrintMemoryUsage();
     QString status;
     mitk::DataNode::Pointer node;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(3*nrFolders);
 
     while(m_Controls->listWidget->count())
     {
 
       // RETREIVE FOLDERNAME
       QListWidgetItem * item  = m_Controls->listWidget->takeItem(0);
       QString folderName = item->text();
 
       // PARSING DIRECTORY
       PrintMemoryUsage();
       clock.Start(folderName.toAscii());
       std::vector<std::string> seriesUIDs(0);
       std::vector<std::vector<std::string> > seriesFilenames(0);
 #ifndef DGDCM2
       Status(QString("Parsing directory %1").arg(folderName));
       typedef itk::GDCMSeriesFileNames InputNamesType;
       InputNamesType::Pointer inputNames = InputNamesType::New();
 
       //////////////////////////////////////////////////////
       ////
       //// if you get seg-faults around here, make sure
       //// to set the itk GDCM_DIR variable in cmake
       //// correctly when building ITK
       //// ( e.g. [itk binary dir]/Utilities/gdcm
       ////   if not using system gdcm )
       ////
       //////////////////////////////////////////////////////
 
       inputNames->SetRecursive(m_Controls->m_DicomLoadRecursiveCheckbox->isChecked());
       inputNames->SetUseSeriesDetails(true);
       inputNames->AddSeriesRestriction( "0020|0012" );
       inputNames->SetInputDirectory( folderName.toAscii() );
       mitk::ProgressBar::GetInstance()->Progress();
       seriesUIDs = inputNames->GetSeriesUIDs();
       unsigned int size = seriesUIDs.size();
       for ( unsigned int i = 0 ; i < size ; ++i )
       {
         seriesFilenames.push_back(inputNames->GetFileNames(seriesUIDs[i]));
       }
 #else
 
       Status("== Initial Directory Scan ==");
       gdcm::Directory d;
       d.Load( folderName.toStdString().c_str(), true ); // recursive !
       const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
       const unsigned int ntotalfiles = l1.size();
       Status(QString(" ... found %1 different files").arg(ntotalfiles));
 
       Status("Scanning Headers");
       gdcm::Scanner s;
       const gdcm::Tag t1(0x0020,0x000d); // Study Instance UID
       const gdcm::Tag t2(0x0020,0x000e); // Series Instance UID
       const gdcm::Tag t5(0x0028, 0x0010); // number rows
       const gdcm::Tag t6(0x0028, 0x0011); // number cols
       s.AddTag( t1 );
       s.AddTag( t2 );
       s.AddTag( t5 );
       s.AddTag( t6 );
 
       bool b = s.Scan( d.GetFilenames() );
       if( !b )
       {
         Error("Scanner failed");
         continue;
       }
 
       // Only get the DICOM files:
       gdcm::Directory::FilenamesType l2 = s.GetKeys();
       const int nfiles = l2.size();
       if(nfiles < 1)
       {
         Error("No DICOM files found");
         continue;
       }
       Status(QString(" ... successfully scanned %1 headers.").arg(nfiles));
 
       Status("Sorting");
 
       const gdcm::Scanner::ValuesType &values1 = s.GetValues(t1);
       int nvalues = values1.size();
       if(nvalues>1)
       {
         Error("Multiple studies found. Please limit to 1 study per folder");
         continue;
       }
 
       const gdcm::Scanner::ValuesType &values5 = s.GetValues(t5);
       const gdcm::Scanner::ValuesType &values6 = s.GetValues(t6);
       if(values5.size()>1 || values6.size()>1)
       {
         Error("Folder contains images of unequal dimensions that cannot be combined in one 3d volume. ABORTING.");
         continue;
       }
 
       const gdcm::Scanner::ValuesType &values2 = s.GetValues(t2);
       int nSeries = values2.size();
 
       gdcm::Directory::FilenamesType files;
       if(nSeries > 1)
       {
         gdcm::Sorter sorter;
         sorter.SetSortFunction( SortBySeriesUID );
         sorter.StableSort( l2 );
         files = sorter.GetFilenames();
       }
       else
       {
         files = l2;
       }
 
       unsigned int nTotalAcquis = 0;
 
       if(nfiles % nSeries != 0)
       {
         Error("Number of files in series not equal, ABORTING");
         continue;
       }
 
       int filesPerSeries = nfiles / nSeries;
 
       gdcm::Scanner::ValuesType::const_iterator it2 = values2.begin();
       for(int i=0; i<nSeries; i++)
       {
 
         gdcm::Directory::FilenamesType sub( files.begin() + i*filesPerSeries, files.begin() + (i+1)*filesPerSeries);
 
         gdcm::Scanner s;
         const gdcm::Tag t3(0x0020,0x0012);  // Acquisition ID
         const gdcm::Tag t4(0x0018, 0x0024); // Sequence Name (in case acquisitions are equal for all)
         //        const gdcm::Tag t5(0x20,0x32) );    // Image Position (Patient)
         s.AddTag(t3);
         s.AddTag(t4);
         //        s.AddTag(t5);
 
         bool b = s.Scan( sub );
         if( !b )
         {
           Error("Scanner failed");
           continue;
         }
 
         gdcm::Sorter subsorter;
         gdcm::Scanner::ValuesType::const_iterator it;
 
         const gdcm::Scanner::ValuesType &values3 = s.GetValues(t3);
         const gdcm::Scanner::ValuesType &values4 = s.GetValues(t4);;
         unsigned int nAcquis = values3.size();
 
         if(nAcquis != 1)
         {
           subsorter.SetSortFunction( SortByAcquisitionNumber );
           it = values3.begin();
         }
         else
         {
           nAcquis = values4.size();
           subsorter.SetSortFunction( SortBySeqName );
           it = values4.begin();
         }
         nTotalAcquis += nAcquis;
         subsorter.Sort( sub );
 
         if(filesPerSeries % nAcquis != 0)
         {
           Error("Number of files per acquisition not equal, ABORTING");
           continue;
         }
 
         int filesPerAcqu = filesPerSeries / nAcquis;
 
         gdcm::Directory::FilenamesType subfiles = subsorter.GetFilenames();
         for ( unsigned int j = 0 ; j < nAcquis ; ++j )
         {
           std::string identifier = "serie_" + *it2 + "_acquis_" + *it++;
 
           gdcm::IPPSorter ippsorter;
           gdcm::Directory::FilenamesType ipplist((j)*filesPerAcqu+subfiles.begin(),(j+1)*filesPerAcqu+subfiles.begin());
           ippsorter.SetComputeZSpacing( false );
           if( !ippsorter.Sort( ipplist ) )
           {
             Error(QString("Failed to sort acquisition %1, ABORTING").arg(identifier.c_str()));
             continue;
           }
           const std::vector<std::string> & list = ippsorter.GetFilenames();
           seriesFilenames.push_back(list);
           seriesUIDs.push_back(identifier.c_str());
         }
         ++it2;
       }
 
       if(nfiles % nTotalAcquis != 0)
       {
         Error("Number of files per acquisition differs between series, ABORTING");
         continue;
       }
 
       int slices = nfiles/nTotalAcquis;
       Status(QString("Series is composed of %1 different 3D volumes with %2 slices.").arg(nTotalAcquis).arg(slices));
 
 #endif
 
       // READING HEADER-INFOS
       PrintMemoryUsage();
       Status(QString("Reading Headers %1").arg(folderName));
 
       mitk::DicomDiffusionImageHeaderReader::Pointer headerReader;
       mitk::GroupDiffusionHeadersFilter::InputType inHeaders;
       unsigned int size2 = seriesUIDs.size();
       for ( unsigned int i = 0 ; i < size2 ; ++i )
       {
         Status(QString("Reading header image #%1/%2").arg(i+1).arg(size2));
         headerReader = mitk::DicomDiffusionImageHeaderReader::New();
         headerReader->SetSeriesDicomFilenames(seriesFilenames[i]);
         headerReader->Update();
         inHeaders.push_back(headerReader->GetOutput());
         //Status(std::endl;
       }
       mitk::ProgressBar::GetInstance()->Progress();
 
       //        // GROUP HEADERS
       //        mitk::GroupDiffusionHeadersFilter::Pointer grouper
       //            = mitk::GroupDiffusionHeadersFilter::New();
       //        mitk::GroupDiffusionHeadersFilter::OutputType outHeaders;
       //        grouper->SetInput(inHeaders);
       //        grouper->Update();
       //        outHeaders = grouper->GetOutput();
 
       // READ VOLUMES
       PrintMemoryUsage();
       Status(QString("Loading Volumes %1").arg(folderName));
       typedef short PixelValueType;
       typedef mitk::DicomDiffusionImageReader< PixelValueType, 3 > VolumesReader;
       VolumesReader::Pointer vReader = VolumesReader::New();
       VolumesReader::HeaderContainer hc = inHeaders;
 
       //        hc.insert(hc.end(), outHeaders[1].begin(), outHeaders[1].end() );
       //        hc.insert(hc.end(), outHeaders[2].begin(), outHeaders[2].end() );
       if(hc.size()>1)
       {
         vReader->SetHeaders(hc);
         vReader->Update();
         VolumesReader::OutputImageType::Pointer vecImage;
         vecImage = vReader->GetOutput();
         Status(QString("Volumes Loaded (%1)").arg(folderName));
 
         // CONSTRUCT CONTAINER WITH DIRECTIONS
         typedef vnl_vector_fixed< double, 3 >            GradientDirectionType;
         typedef itk::VectorContainer< unsigned int,
         GradientDirectionType >                  GradientDirectionContainerType;
         GradientDirectionContainerType::Pointer directions =
             GradientDirectionContainerType::New();
         std::vector<double> b_vals;
         double maxb = 0;
         for(unsigned int i=0; i<hc.size(); i++)
         {
           double bv = hc[i]->bValue;
           if(maxb<bv)
           {
             maxb = bv;
           }
           b_vals.push_back(bv);
         }
 
         for(unsigned int i=0; i<hc.size(); i++)
         {
           vnl_vector_fixed<double, 3> vect = hc[i]->DiffusionVector;
           vect.normalize();
           vect *= sqrt(b_vals[i]/maxb);
           directions->push_back(vect);
         }
 
         // DWI TO DATATREE
         PrintMemoryUsage();
         Status(QString("Initializing Diffusion Image"));
         typedef mitk::DiffusionImage<PixelValueType> DiffVolumesType;
         DiffVolumesType::Pointer diffImage = DiffVolumesType::New();
         diffImage->SetDirections(directions);
         diffImage->SetOriginalDirections(directions);
         if(m_Controls->m_DicomLoadDKFZ->isChecked())
         {
           diffImage->CorrectDKFZBrokenGradientScheme(m_Controls->m_Blur->value());
         }
         diffImage->SetVectorImage(vecImage);
         diffImage->SetB_Value(maxb);
         diffImage->InitializeFromVectorImage();
         Status(QString("Diffusion Image initialized"));
 
         if(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked())
         {
           PrintMemoryUsage();
           Status(QString("Averaging gradient directions"));
           diffImage->AverageRedundantGradients(m_Controls->m_Blur->value());
         }
 
         //if(m_Controls->m_DicomLoadDuplicateIfSingleSliceCheckbox->isChecked())
         //  diffVolumes->DuplicateIfSingleSlice();
 
         QString descr = QString("%1_%2_%3")
                         .arg(((inHeaders)[0])->seriesDescription.c_str())
                         .arg(((inHeaders)[0])->seriesNumber)
                         .arg(((inHeaders)[0])->patientName.c_str());
         descr = descr.trimmed();
         descr = descr.replace(" ", "_");
 
         if(!m_OutputFolderNameSet)
         {
           node=mitk::DataNode::New();
           node->SetData( diffImage );
           GetDefaultDataStorage()->Add(node);
           SetDwiNodeProperties(node, descr.toStdString().c_str());
           Status(QString("Image %1 added to datastorage").arg(descr));
         }
         else
         {
           typedef mitk::NrrdDiffusionImageWriter<PixelValueType> WriterType;
           WriterType::Pointer writer = WriterType::New();
           QString fullpath = QString("%1/%2.dwi")
                              .arg(m_OutputFolderName)
                              .arg(descr);
           std::string pathstring = itksys::SystemTools::ConvertToOutputPath(fullpath.toStdString().c_str());
           writer->SetFileName(pathstring);
           writer->SetInput(diffImage);
           try
           {
             writer->Update();
           }
           catch (itk::ExceptionObject &ex)
           {
             Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
             continue ;
           }
           Status(QString("Image %1 written to disc (%1)").arg(fullpath.toStdString().c_str()));
         }
       }
       else
       {
         Status(QString("No diffusion information found (%1)").arg(folderName));
       }
 
       Status(QString("Finished processing %1 with memory:").arg(folderName));
       PrintMemoryUsage();
       clock.Stop(folderName.toAscii());
       mitk::ProgressBar::GetInstance()->Progress();
     }
 
     Status("Timing information");
     clock.Report();
     
     if(!m_OutputFolderNameSet && node.IsNotNull())
     {
       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();
 
   }
   catch (itk::ExceptionObject &ex)
   {
     Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
     return ;
   }
 
   Status(QString("Finished import with memory:"));
   PrintMemoryUsage();
 }
 
 void QmitkDiffusionDicomImport::SetDwiNodeProperties(mitk::DataNode::Pointer node, std::string name)
 {
 
   node->SetProperty( "IsDWIRawVolume", mitk::BoolProperty::New( true ) );
 
   // set foldername as string property
   mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
   node->SetProperty( "name", nameProp );
 }
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.h
index 0c9d7d5971..13aee8814f 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.h
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.h
@@ -1,114 +1,115 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-05 11:31:02 +0200 (Di, 05 Mai 2009) $
 Version:   $Revision: 10185 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef QmitkDiffusionDicomImportView_H__INCLUDED
 #define QmitkDiffusionDicomImportView_H__INCLUDED
 
 #include "QmitkFunctionality.h"
 #include "ui_QmitkDiffusionDicomImportViewControls.h"
 
 
 /*!
 \brief QmitkDiffusionDicomImport 
 
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
-class QmitkDiffusionDicomImport : public QObject, public QmitkFunctionality
+class QmitkDiffusionDicomImport : public QmitkFunctionality
 {  
   Q_OBJECT
 
 public:  
 
   static const std::string VIEW_ID;
 
   /*! 
   \  Convenient typedefs
   */
   typedef mitk::DataStorage::SetOfObjects  ConstVector;
   typedef ConstVector::ConstPointer        ConstVectorPointer;
   typedef ConstVector::ConstIterator       ConstVectorIterator;
 
   /*!  
   \brief default constructor  
   */  
   QmitkDiffusionDicomImport(QObject *parent=0, const char *name=0);
+  QmitkDiffusionDicomImport(const QmitkDiffusionDicomImport& other);
 
   /*!  
   \brief default destructor  
   */  
   virtual ~QmitkDiffusionDicomImport();
 
   /*!  
   \brief method for creating the widget containing the application   controls, like sliders, buttons etc.  
   */  
   virtual void CreateQtPartControl(QWidget *parent);
 
   /*!  
   \brief method for creating the connections of main and control widget  
   */  
   virtual void CreateConnections();
 
   virtual void Activated();
 
   void SetDwiNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
   protected slots:  
 
     void DicomLoadAddFolderNames();
 
     void DicomLoadDeleteFolderNames(); 
 
     void DicomLoadStartLoad() ;
 
     void AverageClicked();
 
     void OutputSet();
     void OutputClear();
 
 protected: 
 
   void Status(QString status);
   void Status(std::string status);
   void Status(const char* status);
   void Error(QString status);
   void Error(std::string status);
   void Error(const char* status);
 
   void PrintMemoryUsage();
   std::string FormatMemorySize( size_t size );
   std::string FormatPercentage( double val );
   std::string GetMemoryDescription( size_t processSize, float percentage );
 
   /*!  
   * controls containing sliders for scrolling through the slices  
   */  
   Ui::QmitkDiffusionDicomImportControls *m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
   QWidget *m_Parent;
 
   QString m_OutputFolderName;
   bool m_OutputFolderNameSet;
 
 };
 
 #endif // !defined(QmitkDiffusionDicomImport_H__INCLUDED)
 
 
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionImagingPublicPerspective.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionImagingPublicPerspective.cpp
index b897c5b1ca..1fa8ea91ab 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionImagingPublicPerspective.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionImagingPublicPerspective.cpp
@@ -1,68 +1,79 @@
 /*=========================================================================
  
  Program:   BlueBerry Platform
  Language:  C++
  Date:      $Date: 2009-10-23 02:59:36 +0200 (Fr, 23 Okt 2009) $
  Version:   $Revision: 19652 $
  
  Copyright (c) German Cancer Research Center, Division of Medical and
  Biological Informatics. All rights reserved.
  See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
  
  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.  See the above copyright notices for more information.
  
  =========================================================================*/
 
 #include "QmitkDiffusionImagingPublicPerspective.h"
 #include "berryIViewLayout.h"
 
+QmitkDiffusionImagingPublicPerspective::QmitkDiffusionImagingPublicPerspective()
+{
+
+}
+
+QmitkDiffusionImagingPublicPerspective::QmitkDiffusionImagingPublicPerspective(const QmitkDiffusionImagingPublicPerspective& other)
+{
+  Q_UNUSED(other)
+  throw std::runtime_error("Copy constructor not implemented");
+}
+
 void QmitkDiffusionImagingPublicPerspective::CreateInitialLayout(berry::IPageLayout::Pointer layout)
 {
   std::string editorArea = layout->GetEditorArea();
 
   layout->AddStandaloneView("org.mitk.views.datamanager", 
     false, berry::IPageLayout::LEFT, 0.3f, editorArea);
 
   layout->AddStandaloneView("org.mitk.views.controlvisualizationpropertiesview", 
     false, berry::IPageLayout::BOTTOM, .2f, "org.mitk.views.datamanager");
 
   berry::IFolderLayout::Pointer left =
     layout->CreateFolder("org.mitk.leftcontrols", 
     berry::IPageLayout::BOTTOM, 0.125f, "org.mitk.views.controlvisualizationpropertiesview");
 
   layout->AddStandaloneView("org.mitk.views.imagenavigator",
     false, berry::IPageLayout::BOTTOM, 0.8f, "org.mitk.leftcontrols");
 
   layout->AddStandaloneView("org.mitk.views.perspectiveswitcher",
     false, berry::IPageLayout::BOTTOM, 0.99f, "org.mitk.views.imagenavigator");
 
 //  layout->AddStandaloneViewPlaceholder("org.mitk.views.imagenavigator",
 //    berry::IPageLayout::TOP, 0.9f, "org.mitk.views.perspectiveswitcher",false);
   
   left->AddView("org.mitk.views.diffusionpreprocessing");
   left->AddView("org.mitk.views.tensorreconstruction");
   left->AddView("org.mitk.views.qballreconstruction");
   left->AddView("org.mitk.views.diffusionquantification");
   left->AddView("org.mitk.views.diffusiondicomimport");
 
   berry::IViewLayout::Pointer lo = layout->GetViewLayout("org.mitk.views.diffusionpreprocessing");
   lo->SetCloseable(false);
 
   lo = layout->GetViewLayout("org.mitk.views.qballreconstruction");
   lo->SetCloseable(false);
 
   lo = layout->GetViewLayout("org.mitk.views.tensorreconstruction");
   lo->SetCloseable(false);
 
   lo = layout->GetViewLayout("org.mitk.views.diffusionquantification");
   lo->SetCloseable(false);
 
   lo = layout->GetViewLayout("org.mitk.views.diffusiondicomimport");
   lo->SetCloseable(false);
 
   //berry::IFolderLayout::Pointer right2 =
   //  layout->CreateFolder("right2", berry::IPageLayout::BOTTOM, 0.5f, "right");
 
 }
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionImagingPublicPerspective.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionImagingPublicPerspective.h
index a5288646e7..12013e5d92 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionImagingPublicPerspective.h
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionImagingPublicPerspective.h
@@ -1,31 +1,37 @@
 /*=========================================================================
  
  Program:   BlueBerry Platform
  Language:  C++
  Date:      $Date: 2009-10-23 02:59:36 +0200 (Fr, 23 Okt 2009) $
  Version:   $Revision: 19652 $
  
  Copyright (c) German Cancer Research Center, Division of Medical and
  Biological Informatics. All rights reserved.
  See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
  
  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.  See the above copyright notices for more information.
  
  =========================================================================*/
 
 
 #ifndef QMITKDIFFUSIONIMAGINGPUBLICPERSPECTIVE_H_
 #define QMITKDIFFUSIONIMAGINGPUBLICPERSPECTIVE_H_
 
 #include <berryIPerspectiveFactory.h>
 
-class QmitkDiffusionImagingPublicPerspective : public berry::IPerspectiveFactory
+class QmitkDiffusionImagingPublicPerspective : public QObject, public berry::IPerspectiveFactory
 {
+  Q_OBJECT
+  Q_INTERFACES(berry::IPerspectiveFactory)
+
 public:
 
+  QmitkDiffusionImagingPublicPerspective();
+  QmitkDiffusionImagingPublicPerspective(const QmitkDiffusionImagingPublicPerspective& other);
+
   void CreateInitialLayout(berry::IPageLayout::Pointer layout);
 };
 
 #endif /* QMITKDIFFUSIONIMAGINGPUBLICPERSPECTIVE_H_ */
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.cpp
index cd056aa261..05fb4de3a3 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.cpp
@@ -1,649 +1,655 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkDiffusionQuantificationView.h"
 #include "mitkDiffusionImagingConfigure.h"
 
 #include "itkTimeProbe.h"
 #include "itkImage.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkQBallImage.h"
 #include "mitkImageCast.h"
 #include "mitkStatusBar.h"
 #include "itkDiffusionQballGeneralizedFaImageFilter.h"
 #include "itkShiftScaleImageFilter.h"
 #include "itkTensorFractionalAnisotropyImageFilter.h"
 #include "itkTensorRelativeAnisotropyImageFilter.h"
 #include "itkTensorDerivedMeasurementsFilter.h"
 
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 
 #include <QMessageBox>
 
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 
 const std::string QmitkDiffusionQuantificationView::VIEW_ID = "org.mitk.views.diffusionquantification";
 
 using namespace berry;
 
 const float QmitkDiffusionQuantificationView::m_ScaleDAIValues = 100.0;
 
 struct DqSelListener : ISelectionListener
 {
 
   berryObjectMacro(DqSelListener);
 
   DqSelListener(QmitkDiffusionQuantificationView* 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 foundQBIVolume = false;
       bool foundTensorVolume = false;
 
       // 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();
 
           // only look at interesting types
           if(QString("QBallImage").compare(node->GetData()->GetNameOfClass())==0)
           {
             foundQBIVolume = true;
           }
 
           if(QString("TensorImage").compare(node->GetData()->GetNameOfClass())==0)
           {
             foundTensorVolume = true;
           }
         }
       }
 
       m_View->m_Controls->m_GFAButton->setEnabled(foundQBIVolume);
       m_View->m_Controls->m_CurvatureButton->setEnabled(foundQBIVolume);
 
       m_View->m_Controls->m_FAButton->setEnabled(foundTensorVolume);
       m_View->m_Controls->m_RAButton->setEnabled(foundTensorVolume);
       m_View->m_Controls->m_ADButton->setEnabled(foundTensorVolume);
       m_View->m_Controls->m_RDButton->setEnabled(foundTensorVolume);
       m_View->m_Controls->m_ClusteringAnisotropy->setEnabled(foundTensorVolume);
     }
   }
 
   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);
 
       }
     }
   }
 
   QmitkDiffusionQuantificationView* m_View;
 };
 
 QmitkDiffusionQuantificationView::QmitkDiffusionQuantificationView()
 : QmitkFunctionality(),
 m_Controls(NULL),
 m_MultiWidget(NULL)
 {
 }
 
+QmitkDiffusionQuantificationView::QmitkDiffusionQuantificationView(const QmitkDiffusionQuantificationView& other)
+{
+  Q_UNUSED(other)
+  throw std::runtime_error("Copy constructor not implemented");
+}
+
 QmitkDiffusionQuantificationView::~QmitkDiffusionQuantificationView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 void QmitkDiffusionQuantificationView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkDiffusionQuantificationViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
     GFACheckboxClicked();
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     m_Controls->m_StandardGFACheckbox->setVisible(false);
     m_Controls->frame_3->setVisible(false);
     m_Controls->m_CurvatureButton->setVisible(false);
 #endif
   }
 
   m_SelListener = berry::ISelectionListener::Pointer(new DqSelListener(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<DqSelListener>()->DoSelectionChanged(sel);
 }
 
 void QmitkDiffusionQuantificationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkDiffusionQuantificationView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkDiffusionQuantificationView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_StandardGFACheckbox), SIGNAL(clicked()), this, SLOT(GFACheckboxClicked()) );
     connect( (QObject*)(m_Controls->m_GFAButton), SIGNAL(clicked()), this, SLOT(GFA()) );
     connect( (QObject*)(m_Controls->m_CurvatureButton), SIGNAL(clicked()), this, SLOT(Curvature()) );
     connect( (QObject*)(m_Controls->m_FAButton), SIGNAL(clicked()), this, SLOT(FA()) );
     connect( (QObject*)(m_Controls->m_RAButton), SIGNAL(clicked()), this, SLOT(RA()) );
     connect( (QObject*)(m_Controls->m_ADButton), SIGNAL(clicked()), this, SLOT(AD()) );
     connect( (QObject*)(m_Controls->m_RDButton), SIGNAL(clicked()), this, SLOT(RD()) );
     connect( (QObject*)(m_Controls->m_ClusteringAnisotropy), SIGNAL(clicked()), this, SLOT(ClusterAnisotropy()) );
   }
 }
 
 void QmitkDiffusionQuantificationView::Activated()
 {
   berry::ISelection::ConstPointer sel(
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<DqSelListener>()->DoSelectionChanged(sel);
   QmitkFunctionality::Activated();
 }
 
 void QmitkDiffusionQuantificationView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkDiffusionQuantificationView::GFACheckboxClicked()
 {
   m_Controls->frame_2->setVisible(m_Controls->
     m_StandardGFACheckbox->isChecked());
 }
 
 void QmitkDiffusionQuantificationView::GFA()
 {
   if(m_Controls->m_StandardGFACheckbox->isChecked())
   {
     QBIQuantify(13);
   }
   else
   {
     QBIQuantify(0);
   }
 }
 
 void QmitkDiffusionQuantificationView::Curvature()
 {
   QBIQuantify(12);
 }
 
 void QmitkDiffusionQuantificationView::FA()
 {
   TensorQuantify(0);
 }
 
 void QmitkDiffusionQuantificationView::RA()
 {
   TensorQuantify(1);
 }
 
 void QmitkDiffusionQuantificationView::AD()
 {
   TensorQuantify(2);
 }
 
 void QmitkDiffusionQuantificationView::RD()
 {
   TensorQuantify(3);
 }
 
 void QmitkDiffusionQuantificationView::ClusterAnisotropy()
 {
   TensorQuantify(4);
 }
 
 void QmitkDiffusionQuantificationView::QBIQuantify(int method)
 {
   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("QBallImage").compare(node->GetData()->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
  
     QBIQuantification(set, method);
 
   }
 }
 
 void QmitkDiffusionQuantificationView::TensorQuantify(int method)
 {
   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("TensorImage").compare(node->GetData()->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
  
     TensorQuantification(set, method);
 
   }
 }
 
 void QmitkDiffusionQuantificationView::QBIQuantification(
   mitk::DataStorage::SetOfObjects::Pointer inImages, int method) 
 {
   itk::TimeProbe clock;
   QString status;
 
   int nrFiles = inImages->size();
   if (!nrFiles) return;
 
   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
   {
 
     typedef float TOdfPixelType;
     const int odfsize = QBALL_ODFSIZE;
     typedef itk::Vector<TOdfPixelType,odfsize> OdfVectorType;
     typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
     mitk::Image* vol = 
       static_cast<mitk::Image*>((*itemiter)->GetData());
     OdfVectorImgType::Pointer itkvol = OdfVectorImgType::New();
     mitk::CastToItkImage<OdfVectorImgType>(vol, itkvol);
 
     std::string nodename;
     (*itemiter)->GetStringProperty("name", nodename);
     ++itemiter;
 
     float p1 = m_Controls->m_ParamKEdit->text().toFloat();
     float p2 = m_Controls->m_ParamPEdit->text().toFloat();
 
     // COMPUTE RA
     clock.Start();
     MBI_INFO << "Computing GFA ";
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
       "Computing GFA for %s", nodename.c_str()).toAscii());
     typedef OdfVectorType::ValueType                 RealValueType;
     typedef itk::Image< RealValueType, 3 >                 RAImageType;
     typedef itk::DiffusionQballGeneralizedFaImageFilter<TOdfPixelType,TOdfPixelType,odfsize>
       GfaFilterType;
     GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
     gfaFilter->SetInput(itkvol);
     gfaFilter->SetNumberOfThreads(8);
 
     double scale = 1;
     std::string newname;
     newname.append(nodename);
     switch(method)
     {
     case 0:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
         newname.append("GFA");
         scale = m_ScaleDAIValues;
         break;
       }
     case 1:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILES_HIGH_LOW);
         newname.append("01");
         scale = m_ScaleDAIValues;
         break;
       }
     case 2:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILE_HIGH);
         newname.append("02");
         scale = m_ScaleDAIValues;
         break;
       }
     case 3:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_MAX_ODF_VALUE);
         newname.append("03");
         scale = m_ScaleDAIValues;
         break;
       }
     case 4:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_DECONVOLUTION_COEFFS);
         newname.append("04");
         scale = m_ScaleDAIValues;
         break;
       }
     case 5:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_MIN_MAX_NORMALIZED_STANDARD);
         newname.append("05");
         scale = m_ScaleDAIValues;
         break;
       }    
     case 6:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_NORMALIZED_ENTROPY);
         newname.append("06");
         break;
       }
     case 7:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_NEMATIC_ORDER_PARAMETER);
         newname.append("07");
         scale = m_ScaleDAIValues;
         break;
       }
     case 8:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILES_LOW_HIGH);
         newname.append("08");
         scale = m_ScaleDAIValues;
         break;
       }
     case 9:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILE_LOW);
         newname.append("09");
         scale = m_ScaleDAIValues;
         break;
       }
     case 10:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_MIN_ODF_VALUE);
         newname.append("10");
         scale = m_ScaleDAIValues;
         break;
       }
     case 11:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_STD_BY_MAX);
         newname.append("11");
         scale = m_ScaleDAIValues;
         break;
       }
     case 12:
       {
         p1 = m_Controls->MinAngle->text().toFloat();
         p2 = m_Controls->MaxAngle->text().toFloat();
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_PRINCIPLE_CURVATURE);
         QString paramString;
         paramString = paramString.append("PC%1-%2").arg(p1).arg(p2);
         newname.append(paramString.toAscii());
         gfaFilter->SetParam1(p1);
         gfaFilter->SetParam2(p2);
         scale = m_ScaleDAIValues;
         break;
       }
     case 13:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_GENERALIZED_GFA);
         QString paramString;
         paramString = paramString.append("GFAK%1P%2").arg(p1).arg(p2);
         newname.append(paramString.toAscii());
         gfaFilter->SetParam1(p1);
         gfaFilter->SetParam2(p2);
         scale = m_ScaleDAIValues;
         break;
       }
     default:
       {
         newname.append("0");
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
         scale = m_ScaleDAIValues;
       }
     }
     gfaFilter->Update();
     clock.Stop();
     MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
 
     typedef itk::Image<TOdfPixelType, 3> ImgType;
     ImgType::Pointer img = ImgType::New();
     img->SetSpacing( gfaFilter->GetOutput()->GetSpacing() );   // Set the image spacing
     img->SetOrigin( gfaFilter->GetOutput()->GetOrigin() );     // Set the image origin
     img->SetDirection( gfaFilter->GetOutput()->GetDirection() );  // Set the image direction
     img->SetLargestPossibleRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion());
     img->SetBufferedRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion() );
     img->Allocate();
     itk::ImageRegionIterator<ImgType> ot (img, img->GetLargestPossibleRegion() );
     ot = ot.Begin();
     itk::ImageRegionConstIterator<GfaFilterType::OutputImageType> it 
       (gfaFilter->GetOutput(), gfaFilter->GetOutput()->GetLargestPossibleRegion() );
     it = it.Begin();
 
     for (it = it.Begin(); !it.IsAtEnd(); ++it)
     {
       GfaFilterType::OutputImageType::PixelType val = it.Get();
       ot.Set(val * scale);
       ++ot;
     }
 
 
     // GFA TO DATATREE
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk( img.GetPointer() );
     image->SetVolume( img->GetBufferPointer() );
     mitk::DataNode::Pointer node=mitk::DataNode::New();
     node->SetData( image );
     node->SetProperty( "name", mitk::StringProperty::New(newname) );    
     nodes.push_back(node);
  
     mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
 
   }
 
   std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
   for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
     GetDefaultDataStorage()->Add(*nodeIt);
 
   m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkDiffusionQuantificationView::TensorQuantification(
   mitk::DataStorage::SetOfObjects::Pointer inImages, int method) 
 {
   itk::TimeProbe clock;
   QString status;
 
   int nrFiles = inImages->size();
   if (!nrFiles) return;
 
   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
   {
 
     typedef float                                       TTensorPixelType;
     typedef itk::DiffusionTensor3D< TTensorPixelType >  TensorPixelType;
     typedef itk::Image< TensorPixelType, 3 >            TensorImageType;
 
     mitk::Image* vol = 
       static_cast<mitk::Image*>((*itemiter)->GetData());
     TensorImageType::Pointer itkvol = TensorImageType::New();
     mitk::CastToItkImage<TensorImageType>(vol, itkvol);
 
     std::string nodename;
     (*itemiter)->GetStringProperty("name", nodename);
     ++itemiter;
 
     // COMPUTE FA
     clock.Start();
     MBI_INFO << "Computing FA ";
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
       "Computing FA for %s", nodename.c_str()).toAscii());
     typedef itk::Image< TTensorPixelType, 3 >              FAImageType;
 
     typedef itk::ShiftScaleImageFilter<FAImageType, FAImageType> 
       ShiftScaleFilterType;
     ShiftScaleFilterType::Pointer multi =
       ShiftScaleFilterType::New();
     multi->SetShift(0.0);
     multi->SetScale(m_ScaleDAIValues);//itk::NumericTraits<RealValueType>::max()
 
     typedef itk::TensorDerivedMeasurementsFilter<TTensorPixelType> MeasurementsType;
 
     if(method == 0) //FA
     {
      /* typedef itk::TensorFractionalAnisotropyImageFilter< 
         TensorImageType, FAImageType >                       FilterType;    
       FilterType::Pointer anisotropyFilter = FilterType::New();
       anisotropyFilter->SetInput( itkvol.GetPointer() );
       anisotropyFilter->Update();
       multi->SetInput(anisotropyFilter->GetOutput());
       nodename = QString(nodename.c_str()).append("_FA").toStdString();*/
 
       
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::FA);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_FA").toStdString();
 
     }
     else if(method == 1) //RA
     {
       /*typedef itk::TensorRelativeAnisotropyImageFilter< 
         TensorImageType, FAImageType >                       FilterType;
       FilterType::Pointer anisotropyFilter = FilterType::New();
       anisotropyFilter->SetInput( itkvol.GetPointer() );
       anisotropyFilter->Update();
       multi->SetInput(anisotropyFilter->GetOutput());
       nodename = QString(nodename.c_str()).append("_RA").toStdString();*/
       
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::RA);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_RA").toStdString();
 
     }  
     else if(method == 2) // AD (Axial diffusivity)
     {
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::AD);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_AD").toStdString();
     }
     else if(method == 3) // RD (Radial diffusivity, (Lambda2+Lambda3)/2
     {
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::RD);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_RD").toStdString();
     }
     else if(method == 4) // 1-(Lambda2+Lambda3)/(2*Lambda1)
     {
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::CA);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_CA").toStdString();
     }
 
     multi->Update();
     clock.Stop();
     MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
 
     // FA TO DATATREE
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk( multi->GetOutput() );
     image->SetVolume( multi->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer node=mitk::DataNode::New();
     node->SetData( image );
     node->SetProperty( "name", mitk::StringProperty::New(nodename) );
     nodes.push_back(node);
  
     mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
 
   }
 
   std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
   for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
     GetDefaultDataStorage()->Add(*nodeIt);
 
   m_MultiWidget->RequestUpdate();
 
 }
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.h
index 96aa65ae8f..b0f2b811fd 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.h
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.h
@@ -1,106 +1,107 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef _QMITKDIFFUSIONQUANTIFICATIONVIEW_H_INCLUDED
 #define _QMITKDIFFUSIONQUANTIFICATIONVIEW_H_INCLUDED
 
 #include <QmitkFunctionality.h>
 
 #include <string>
 
 #include "berryISelectionListener.h"
 #include "berryIStructuredSelection.h"
 
 #include "ui_QmitkDiffusionQuantificationViewControls.h"
 
 
 
 /*!
  * \ingroup org_mitk_gui_qt_diffusionquantification_internal
  *
  * \brief QmitkDiffusionQuantificationView
  *
  * Document your class here.
  *
  * \sa QmitkFunctionality
  */
-class QmitkDiffusionQuantificationView : public QObject, public QmitkFunctionality
+class QmitkDiffusionQuantificationView : public QmitkFunctionality
 {
 
   friend struct DqSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   QmitkDiffusionQuantificationView();
+  QmitkDiffusionQuantificationView(const QmitkDiffusionQuantificationView& other);
   virtual ~QmitkDiffusionQuantificationView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
   /// \brief Called when the functionality is activated
   virtual void Activated();
 
   virtual void Deactivated();
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
 protected slots:
 
   void GFACheckboxClicked();
   
   void GFA();
   void Curvature();
   void FA();
   void RA();
   void AD();
   void RD();
   void ClusterAnisotropy();
 
   void QBIQuantify(int method);
   void QBIQuantification(mitk::DataStorage::SetOfObjects::Pointer inImages, 
     int method) ;
 
   void TensorQuantify(int method);
   void TensorQuantification(mitk::DataStorage::SetOfObjects::Pointer inImages, 
     int method) ;
 
 protected:
 
   Ui::QmitkDiffusionQuantificationViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
   berry::ISelectionListener::Pointer m_SelListener;
   berry::IStructuredSelection::ConstPointer m_CurrentSelection;
 
   static const float m_ScaleDAIValues;
 };
 
 
 
 
 #endif // _QMITKDIFFUSIONQUANTIFICATIONVIEW_H_INCLUDED
 
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
index 5694b60e27..f1d3036cd5 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
@@ -1,401 +1,407 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include "QmitkPreprocessingView.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 "itkVectorContainer.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 "itkB0ImageExtractionImageFilter.h"
 #include "itkBrainMaskExtractionImageFilter.h"
 #include "itkCastImageFilter.h"
 
 #include "berryIStructuredSelection.h"
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 const std::string QmitkPreprocessingView::VIEW_ID = 
 "org.mitk.views.preprocessing";
 
 #define DI_INFO MITK_INFO("DiffusionImaging")
 
 
 typedef float TTensorPixelType;
 
 using namespace berry;
 
 struct PrpSelListener : ISelectionListener
 {
 
   berryObjectMacro(PrpSelListener);
 
   PrpSelListener(QmitkPreprocessingView* 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;
 
       // 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();
 
           // only look at interesting types
           if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
           {
             foundDwiVolume = true;
           }
         }
       }
 
       m_View->m_Controls->m_ButtonBrainMask->setEnabled(foundDwiVolume);
       m_View->m_Controls->m_ButtonAverageGradients->setEnabled(foundDwiVolume);
       m_View->m_Controls->m_ButtonExtractB0->setEnabled(foundDwiVolume);      
     }
   }
 
   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);
 
       }
     }
   }
 
   QmitkPreprocessingView* m_View;
 };
 
 QmitkPreprocessingView::QmitkPreprocessingView()
 : QmitkFunctionality(),
 m_Controls(NULL),
 m_MultiWidget(NULL)
 {
 }
 
+QmitkPreprocessingView::QmitkPreprocessingView(const QmitkPreprocessingView& other)
+{
+  Q_UNUSED(other)
+  throw std::runtime_error("Copy constructor not implemented");
+}
+
 QmitkPreprocessingView::~QmitkPreprocessingView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 void QmitkPreprocessingView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkPreprocessingViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 
   m_SelListener = berry::ISelectionListener::Pointer(new PrpSelListener(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<PrpSelListener>()->DoSelectionChanged(sel);
 }
 
 void QmitkPreprocessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkPreprocessingView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkPreprocessingView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_ButtonAverageGradients), SIGNAL(clicked()), this, SLOT(AverageGradients()) );
     connect( (QObject*)(m_Controls->m_ButtonExtractB0), SIGNAL(clicked()), this, SLOT(ExtractB0()) );
     connect( (QObject*)(m_Controls->m_ButtonBrainMask), SIGNAL(clicked()), this, SLOT(BrainMask()) );
 
   }
 }
 
 void QmitkPreprocessingView::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<PrpSelListener>()->DoSelectionChanged(sel);
 }
 
 void QmitkPreprocessingView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 
 void QmitkPreprocessingView::ExtractB0()
 {
 
   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);
         }
       }
     }
 
     DoExtractB0(set);
 
   }
 }
 
 void QmitkPreprocessingView::DoExtractB0
 (mitk::DataStorage::SetOfObjects::Pointer inImages)
 {
   typedef mitk::DiffusionImage<DiffusionPixelType>              DiffusionImageType;
   typedef DiffusionImageType::GradientDirectionContainerType    GradientContainerType;
 
   int nrFiles = inImages->size();
   if (!nrFiles) return;
 
   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
   {
 
     DiffusionImageType* vols = 
       static_cast<DiffusionImageType*>(
       (*itemiter)->GetData());
 
     std::string nodename;
     (*itemiter)->GetStringProperty("name", nodename);
 
     // Extract image using found index
     typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
     FilterType::Pointer filter = FilterType::New();
     filter->SetInput(vols->GetVectorImage());
     filter->SetDirections(vols->GetDirections());
     filter->Update();
 
     mitk::Image::Pointer mitkImage = mitk::Image::New();
     mitkImage->InitializeByItk( filter->GetOutput() );
     mitkImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer node=mitk::DataNode::New();
     node->SetData( mitkImage );
     node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0"));
 
     GetDefaultDataStorage()->Add(node);
 
     ++itemiter;
   }
 
 
 }
 
 void QmitkPreprocessingView::AverageGradients()
 {
 
   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);
         }
       }
     }
 
     DoAverageGradients(set);
 
   }
 
 }
 
 void QmitkPreprocessingView::DoAverageGradients
 (mitk::DataStorage::SetOfObjects::Pointer inImages) 
 {
   int nrFiles = inImages->size();
   if (!nrFiles) return;
 
   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());
 
     vols->AverageRedundantGradients(m_Controls->m_Blur->value());
 
     ++itemiter;
   }
 }
 
 void QmitkPreprocessingView::BrainMask()
 {
 
   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);
         }
       }
     }
 
     DoBrainMask(set);
 
   }
 
 }
 
 void QmitkPreprocessingView::DoBrainMask
 (mitk::DataStorage::SetOfObjects::Pointer inImages) 
 {
   int nrFiles = inImages->size();
   if (!nrFiles) return;
 
   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);
 
     // Extract image using found index
     typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
     FilterType::Pointer filter = FilterType::New();
     filter->SetInput(vols->GetVectorImage());
     filter->SetDirections(vols->GetDirections());
 
     typedef itk::CastImageFilter<itk::Image<short,3>, itk::Image<unsigned short,3> > CastFilterType;
     CastFilterType::Pointer castfilter = CastFilterType::New();
     castfilter->SetInput(filter->GetOutput());
     
     typedef itk::BrainMaskExtractionImageFilter<unsigned char> MaskFilterType;
     MaskFilterType::Pointer maskfilter = MaskFilterType::New();
     maskfilter->SetInput(castfilter->GetOutput());
     maskfilter->Update();
 
     mitk::Image::Pointer mitkImage = mitk::Image::New();
     mitkImage->InitializeByItk( maskfilter->GetOutput() );
     mitkImage->SetVolume( maskfilter->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer node=mitk::DataNode::New();
     node->SetData( mitkImage );
     node->SetProperty( "name", mitk::StringProperty::New(nodename + "_Mask"));
 
     GetDefaultDataStorage()->Add(node);
 
     ++itemiter;
   }
 }
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
index 5a695ce5be..a4bf179e07 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
@@ -1,106 +1,107 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef _QMITKPREPROCESSINGVIEW_H_INCLUDED
 #define _QMITKPREPROCESSINGVIEW_H_INCLUDED
 
 #include <QmitkFunctionality.h>
 
 #include <string>
 
 #include "ui_QmitkPreprocessingViewControls.h"
 
 #include "mitkDiffusionImage.h"
 
 #include <berryIPartListener.h>
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 typedef short DiffusionPixelType;
 
 struct PrpSelListener;
 
 /*!
  * \ingroup org_mitk_gui_qt_preprocessing_internal
  *
  * \brief QmitkPreprocessingView
  *
  * Document your class here.
  *
  * \sa QmitkFunctionality
  */
-class QmitkPreprocessingView : public QObject, public QmitkFunctionality
+class QmitkPreprocessingView : public QmitkFunctionality
 {
 
   friend struct PrpSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   QmitkPreprocessingView();
+  QmitkPreprocessingView(const QmitkPreprocessingView& other);
   virtual ~QmitkPreprocessingView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
   /// \brief Called when the functionality is activated
   virtual void Activated();
 
   virtual void Deactivated();
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   static const int nrconvkernels;
 
 protected slots:
 
   void AverageGradients();
   void DoAverageGradients(mitk::DataStorage::SetOfObjects::Pointer inImages);
   
   void ExtractB0();
   void DoExtractB0(mitk::DataStorage::SetOfObjects::Pointer inImages);
 
   void BrainMask();
   void DoBrainMask(mitk::DataStorage::SetOfObjects::Pointer inImages);
 
 
 protected:
 
   Ui::QmitkPreprocessingViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
   void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
   berry::ISelectionListener::Pointer m_SelListener;
   berry::IStructuredSelection::ConstPointer m_CurrentSelection;
 
 };
 
 
 
 
 #endif // _QMITKPREPROCESSINGVIEW_H_INCLUDED
 
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
index 1533332132..38f37d4ce2 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
@@ -1,768 +1,774 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 //#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 "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"
 
 #include <boost/version.hpp>
 
 const std::string QmitkQBallReconstructionView::VIEW_ID = 
   "org.mitk.views.qballreconstruction";
 
 #define DI_INFO MITK_INFO("DiffusionImaging")
 
 
 typedef float TTensorPixelType;
 
 const int QmitkQBallReconstructionView::nrconvkernels = 252;
 
 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;
 
       // 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();
           
           // only look at interesting types
           if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
           {
             foundDwiVolume = true;
           }
         }
       }
 
       m_View->m_Controls->m_ButtonStandard->setEnabled(foundDwiVolume);
     }
   }
 
   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()
 : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL)
 {
 }
 
+QmitkQBallReconstructionView::QmitkQBallReconstructionView(const QmitkQBallReconstructionView& other)
+{
+  Q_UNUSED(other);
+  throw std::runtime_error("Copy constructor not implemented");
+}
+
 //void QmitkQBallReconstructionView::OpactiyChanged(int value)
 //{
 //  if (m_CurrentSelection)
 //  {
 //    if (mitk::DataNodeObject::Pointer nodeObj = m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>())
 //    {
 //      mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 //      if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
 //      {
 //        node->SetIntProperty("DisplayChannel", value);
 //        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 //      }
 //    }
 //  }
 //}
 //
 //void QmitkQBallReconstructionView::OpactiyActionChanged()
 //{
 //    if (m_CurrentSelection)
 //  {
 //    if (mitk::DataNodeObject::Pointer nodeObj = m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>())
 //    {
 //      mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 //      if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
 //      {
 //        int displayChannel = 0.0;
 //        if(node->GetIntProperty("DisplayChannel", displayChannel))
 //        {
 //          m_OpacitySlider->setValue(displayChannel);
 //        }
 //      }
 //    }
 //  }
 //    
 //  MITK_INFO << "changed";
 //}
 
 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();
 
     QStringList items;
     items << "2" << "4" << "6" << "8";
     m_Controls->m_QBallReconstructionMaxLLevelComboBox->addItems(items);
     m_Controls->m_QBallReconstructionMaxLLevelComboBox->setCurrentIndex(1);
     m_Controls->m_Description->setText("Spherical harmonics recon. (Desoteaux2007)");
 
     m_Controls->m_QBallReconstructionNumberThreadsSpinbox->setValue(8);
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     m_Controls->m_QBallReconstructionMethodComboBox->removeItem(3);
 #endif
 
     AdvancedCheckboxClicked();
     // define data type for combobox
     //m_Controls->m_ImageSelector->SetDataStorage( this->GetDefaultDataStorage() );
     //m_Controls->m_ImageSelector->SetPredicate( mitk::NodePredicateDataType::New("DiffusionImage") );
   }
 
   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::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;
     }
   }
 }
 
 void QmitkQBallReconstructionView::MethodChoosen(int method)
 {
   switch(method)
   {
   case 0:
     m_Controls->m_Description->setText("Numerical recon. (Tuch2004)");
     break;
   case 1:
     m_Controls->m_Description->setText("Spherical harmonics recon. (Desoteaux2007)");
     break;
   case 2:
     m_Controls->m_Description->setText("SH recon. with solid angle consideration (Aganj2009)");
     break;
   case 3:
     m_Controls->m_Description->setText("SH solid angle with non-neg. constraint (Goh2009)");
     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;
   }
 }
 
 
 
 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->m_OutputB0Image->setVisible(check);
   m_Controls->m_QBallReconstructionNumberThreadsLabel_2->setVisible(check);
   m_Controls->m_QBallReconstructionNumberThreadsSpinbox->setVisible(check);
   m_Controls->label_2->setVisible(check);
 
   //m_Controls->textLabel1_2->setVisible(check);
   //m_Controls->m_QBallReconstructionLambdaStepLineEdit->setVisible(check);
   //m_Controls->textLabel1_3->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);
       }
 #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();
       MBI_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->SetNumberOfThreads( m_Controls->m_QBallReconstructionNumberThreadsSpinbox->value() );
       filter->SetBValue(vols->GetB_Value());  
       filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->text().toFloat() );
 
       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();
       MBI_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);
       
       // B-Zero TO DATATREE
       if(m_Controls->m_OutputB0Image->isChecked())
       {
         mitk::Image::Pointer image4 = mitk::Image::New();
         image4->InitializeByItk( filter->GetBZeroImage().GetPointer() );
         image4->SetVolume( filter->GetBZeroImage()->GetBufferPointer() );
         mitk::DataNode::Pointer node4=mitk::DataNode::New();
         node4->SetData( image4 );
         node4->SetProperty( "name", mitk::StringProperty::New(
           QString(nodename.c_str()).append("_b0").toStdString()) );
         nodes.push_back(node4);
       }
       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)
   {
     MBI_INFO << ex ;
     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->text().toFloat();
     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();
       MBI_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;
           }
         }
 
         clock.Stop();
         MBI_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)
   {
     MBI_INFO << ex ;
     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->SetNumberOfThreads( m_Controls->m_QBallReconstructionNumberThreadsSpinbox->value() );
   filter->SetBValue(vols->GetB_Value());  
   filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->text().toFloat() );
   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);
   
   // B-Zero TO DATATREE
   if(m_Controls->m_OutputB0Image->isChecked())
   {
     mitk::Image::Pointer image4 = mitk::Image::New();
     image4->InitializeByItk( filter->GetBZeroImage().GetPointer() );
     image4->SetVolume( filter->GetBZeroImage()->GetBufferPointer() );
     mitk::DataNode::Pointer node4=mitk::DataNode::New();
     node4->SetData( image4 );
     node4->SetProperty( "name", mitk::StringProperty::New(
       QString(nodename.c_str()).append("_b0").toStdString()) );
     nodes->push_back(node4);
   }  
 }
 
 
 
 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()->SetProperty( "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 );
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
index 149a2512fb..bfc262add3 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
@@ -1,118 +1,119 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
 #define _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
 
 #include <QmitkFunctionality.h>
 
 #include <string>
 
 #include "ui_QmitkQBallReconstructionViewControls.h"
 
 #include "mitkDiffusionImage.h"
 
 #include <berryIPartListener.h>
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 typedef short DiffusionPixelType;
 
 struct QbrSelListener;
 
 /*!
  * \ingroup org_mitk_gui_qt_qballreconstruction_internal
  *
  * \brief QmitkQBallReconstructionView
  *
  * Document your class here.
  *
  * \sa QmitkFunctionality
  */
-class QmitkQBallReconstructionView : public QObject, public QmitkFunctionality
+class QmitkQBallReconstructionView : public QmitkFunctionality
 {
 
   friend struct QbrSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   QmitkQBallReconstructionView();
+  QmitkQBallReconstructionView(const QmitkQBallReconstructionView& other);
   virtual ~QmitkQBallReconstructionView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
   /// \brief Called when the functionality is activated
   virtual void Activated();
 
   virtual void Deactivated();
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   static const int nrconvkernels;
 
 protected slots:
 
   void ReconstructStandard();
   //void ReconstructNormalized1();
   //void ReconstructNormalized2();
   //void ReconstructNonNormalized();
   //void AnalyticallyReconstructStandard();
   //void AnalyticallyReconstructSolidAngle();
   //void AnalyticallyReconstructNonNegSolidAngle();
   //void AnalyticallyReconstructAdc();
   //void AnalyticallyReconstructRaw();
   
   void AdvancedCheckboxClicked();
   void MethodChoosen(int method);
   
   void Reconstruct(int method, int normalization);
   
   void NumericalQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization);
   void AnalyticalQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization);
 
 protected:
 
   Ui::QmitkQBallReconstructionViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
   template<int L>
   void TemplatedAnalyticalQBallReconstruction(mitk::DiffusionImage<DiffusionPixelType>* vols, 
     float lambda, std::string nodename, std::vector<mitk::DataNode::Pointer>* nodes, int normalization);
 
   void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
   berry::ISelectionListener::Pointer m_SelListener;
   berry::IStructuredSelection::ConstPointer m_CurrentSelection;
 
 };
 
 
 
 
 #endif // _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
 
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
index 0f225e9755..21608b7ce9 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
@@ -1,795 +1,801 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkTensorReconstructionView.h"
 #include "mitkDiffusionImagingConfigure.h"
 
 // qt includes
 #include <QMessageBox>
 
 // itk includes
 #include "itkTimeProbe.h"
 //#include "itkTensor.h"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 
 #include "mitkTeemDiffusionTensor3DReconstructionImageFilter.h"
 #include "itkDiffusionTensor3DReconstructionImageFilter.h"
 #include "itkTensorImageToDiffusionImageFilter.h"
 #include "itkPointShell.h"
 #include "itkVector.h"
 
 #include "mitkTensorImage.h"
 #include "mitkProperties.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkDiffusionImageMapper.h"
 
 #include "berryIStructuredSelection.h"
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 const std::string QmitkTensorReconstructionView::VIEW_ID = 
 "org.mitk.views.tensorreconstruction";
 
 #define DI_INFO MITK_INFO("DiffusionImaging")
 
 typedef float TTensorPixelType;
 
 using namespace berry;
 
 struct TrSelListener : ISelectionListener
 {
 
   berryObjectMacro(TrSelListener);
 
   TrSelListener(QmitkTensorReconstructionView* view)
   {
     m_View = view;
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
     //    if(!m_View->IsVisible())
     //      return;
     // 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;
       bool foundTensorVolume = false;
 
       // 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();
 
           // only look at interesting types
           if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
           {
             foundDwiVolume = true;
           }
 
           // only look at interesting types
           if(QString("TensorImage").compare(node->GetData()->GetNameOfClass())==0)
           {
             foundTensorVolume = true;
           }
         }
       }
 
       m_View->m_Controls->m_ItkReconstruction->setEnabled(foundDwiVolume);
       m_View->m_Controls->m_TeemReconstruction->setEnabled(foundDwiVolume);
 
       m_View->m_Controls->m_TensorsToDWIButton->setEnabled(foundTensorVolume);
 
     }
   }
 
   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);
 
       }
     }
   }
 
   QmitkTensorReconstructionView* m_View;
 };
 
 QmitkTensorReconstructionView::QmitkTensorReconstructionView()
 : QmitkFunctionality(),
 m_Controls(NULL),
 m_MultiWidget(NULL)
 {
 }
 
+QmitkTensorReconstructionView::QmitkTensorReconstructionView(const QmitkTensorReconstructionView& other)
+{
+  Q_UNUSED(other)
+  throw std::runtime_error("Copy constructor not implemented");
+}
+
 QmitkTensorReconstructionView::~QmitkTensorReconstructionView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 void QmitkTensorReconstructionView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkTensorReconstructionViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_TensorReconstructionNumberThreadsSpinbox->setValue(8);
 
     QStringList items;
     items << "LLS (Linear Least Squares)"
       << "MLE (Maximum Likelihood)"
       << "NLS (Nonlinear Least Squares)"
       << "WLS (Weighted Least Squares)";
     m_Controls->m_TensorEstimationTeemEstimationMethodCombo->addItems(items);
     m_Controls->m_TensorEstimationTeemEstimationMethodCombo->setCurrentIndex(0);
 
     m_Controls->m_TensorEstimationManualThreashold->setChecked(false);
     m_Controls->m_TensorEstimationTeemSigmaEdit->setText("NaN");
     m_Controls->m_TensorEstimationTeemNumItsSpin->setValue(1);
     m_Controls->m_TensorEstimationTeemFuzzyEdit->setText("0.0");
     m_Controls->m_TensorEstimationTeemMinValEdit->setText("1.0");
 
     m_Controls->m_TensorEstimationTeemNumItsLabel_2->setEnabled(true);
     m_Controls->m_TensorEstimationTeemNumItsSpin->setEnabled(true);
 
     m_Controls->m_TensorsToDWIBValueEdit->setText("1000");
 
     Advanced1CheckboxClicked();
     Advanced2CheckboxClicked();
     TeemCheckboxClicked();
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     m_Controls->m_TeemToggle->setVisible(false);
 #endif
 
     // define data type for combobox
     //m_Controls->m_ImageSelector->SetDataStorage( this->GetDefaultDataStorage() );
     //m_Controls->m_ImageSelector->SetPredicate( mitk::NodePredicateDataType::New("DiffusionImage") );
   }
 
   m_SelListener = berry::ISelectionListener::Pointer(new TrSelListener(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<TrSelListener>()->DoSelectionChanged(sel);
 }
 
 void QmitkTensorReconstructionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   berry::ISelection::ConstPointer sel(
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<TrSelListener>()->DoSelectionChanged(sel);
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkTensorReconstructionView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkTensorReconstructionView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_TeemToggle), SIGNAL(clicked()), this, SLOT(TeemCheckboxClicked()) );
     connect( (QObject*)(m_Controls->m_ItkReconstruction), SIGNAL(clicked()), this, SLOT(ItkReconstruction()) );
     connect( (QObject*)(m_Controls->m_TeemReconstruction), SIGNAL(clicked()), this, SLOT(TeemReconstruction()) );
     connect( (QObject*)(m_Controls->m_TensorEstimationTeemEstimationMethodCombo), SIGNAL(currentIndexChanged(int)), this, SLOT(MethodChoosen(int)) );
     connect( (QObject*)(m_Controls->m_Advanced1), SIGNAL(clicked()), this, SLOT(Advanced1CheckboxClicked()) );
     connect( (QObject*)(m_Controls->m_Advanced2), SIGNAL(clicked()), this, SLOT(Advanced2CheckboxClicked()) );
     connect( (QObject*)(m_Controls->m_TensorEstimationManualThreashold), SIGNAL(clicked()), this, SLOT(ManualThresholdClicked()) );
     connect( (QObject*)(m_Controls->m_TensorsToDWIButton), SIGNAL(clicked()), this, SLOT(TensorsToDWI()) );
   }
 }
 
 void QmitkTensorReconstructionView::TeemCheckboxClicked()
 {
   m_Controls->groupBox_3->setVisible(m_Controls->
     m_TeemToggle->isChecked());  
 }
 
 void QmitkTensorReconstructionView::Advanced1CheckboxClicked()
 {
   bool check = m_Controls->
     m_Advanced1->isChecked();
 
   m_Controls->frame->setVisible(check);
 }
 
 void QmitkTensorReconstructionView::Advanced2CheckboxClicked()
 {
   bool check = m_Controls->
     m_Advanced2->isChecked();
 
   m_Controls->frame_2->setVisible(check);
 }
 
 void QmitkTensorReconstructionView::ManualThresholdClicked()
 {
   m_Controls->m_TensorReconstructionThreasholdEdit_2->setEnabled(
     m_Controls->m_TensorEstimationManualThreashold->isChecked());
 }
 
 void QmitkTensorReconstructionView::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkTensorReconstructionView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkTensorReconstructionView::MethodChoosen(int method)
 {
   m_Controls->m_TensorEstimationTeemNumItsLabel_2->setEnabled(method==3);
   m_Controls->m_TensorEstimationTeemNumItsSpin->setEnabled(method==3);
 }
 
 void QmitkTensorReconstructionView::ItkReconstruction()
 {
   Reconstruct(0);
 }
 
 void QmitkTensorReconstructionView::TeemReconstruction()
 {
   Reconstruct(1);
 }
 
 void QmitkTensorReconstructionView::Reconstruct(int method)
 {
   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)
     {
       ItkTensorReconstruction(set);
     }
 
     if(method == 1)
     {
       TeemTensorReconstruction(set);
     }
 
   }
 }
 
 void QmitkTensorReconstructionView::ItkTensorReconstruction
 (mitk::DataStorage::SetOfObjects::Pointer inImages) 
 {
   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;
 
       // TENSOR RECONSTRUCTION
       clock.Start();
       MBI_INFO << "Tensor reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
         "Tensor reconstruction for %s", nodename.c_str()).toAscii());
       typedef itk::DiffusionTensor3DReconstructionImageFilter< 
         DiffusionPixelType, DiffusionPixelType, TTensorPixelType > TensorReconstructionImageFilterType;
       TensorReconstructionImageFilterType::Pointer tensorReconstructionFilter = 
         TensorReconstructionImageFilterType::New();
       tensorReconstructionFilter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
       tensorReconstructionFilter->SetNumberOfThreads( m_Controls->m_TensorReconstructionNumberThreadsSpinbox->value() );
       tensorReconstructionFilter->SetBValue(vols->GetB_Value());  
       tensorReconstructionFilter->SetThreshold( m_Controls->m_TensorReconstructionThreasholdEdit->text().toFloat() );
       tensorReconstructionFilter->Update();
       clock.Stop();
       MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
 
       // TENSORS TO DATATREE
       mitk::TensorImage::Pointer image = mitk::TensorImage::New();
 
       
       typedef itk::Image<itk::DiffusionTensor3D<TTensorPixelType>, 3> TensorImageType;      
 
       TensorImageType::Pointer tensorImage;
       tensorImage = tensorReconstructionFilter->GetOutput(); 
 
       
 
 
       // Check the tensor for negative eigenvalues
       if(m_Controls->m_CheckNegativeEigenvalues->isChecked())
       {               
         typedef itk::ImageRegionIterator<TensorImageType> TensorImageIteratorType;
         TensorImageIteratorType tensorIt(tensorImage, tensorImage->GetRequestedRegion());
         tensorIt.GoToBegin();
 
         while(!tensorIt.IsAtEnd())
         {
 
           typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
           //typedef itk::Tensor<TTensorPixelType, 3> TensorType2;
 
           TensorType tensor = tensorIt.Get();
          // TensorType2 tensor2;
 
           /*
           for(int i=0; i<tensor.GetNumberOfComponents(); i++)
           {
             tensor2.SetNthComponent(i, tensor.GetNthComponent(i));  
           }
         
           typedef vnl_symmetric_eigensystem< TTensorPixelType >  SymEigenSystemType;
           SymEigenSystemType eig (tensor2.GetVnlMatrix());         
           for(unsigned int i=0; i<eig.D.size(); i++)
           {
             if (eig.D[i] < 0.0 )
             {                       
               tensor.Fill(0.0);
               tensorIt.Set(tensor);              
             }            
           }*/
 
           
           TensorType::EigenValuesArrayType ev;
           tensor.ComputeEigenValues(ev);        
           for(unsigned int i=0; i<ev.Size(); i++)
           {
             if(ev[i] < 0.0)
             {
               tensor.Fill(0.0);
               tensorIt.Set(tensor);              
               break;
             }
           }          
           
 
           ++tensorIt;
         }       
       }
 
 
       image->InitializeByItk( tensorImage.GetPointer() );
       image->SetVolume( tensorReconstructionFilter->GetOutput()->GetBufferPointer() );
       mitk::DataNode::Pointer node=mitk::DataNode::New();
       node->SetData( image );
 
       QString newname;
       newname = newname.append(nodename.c_str());
       newname = newname.append("_dti");
 
       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)
   {
     MBI_INFO << ex ;
     return ;
   }
 }
 
 
 
 void QmitkTensorReconstructionView::TeemTensorReconstruction
 (mitk::DataStorage::SetOfObjects::Pointer inImages) 
 {
   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;
 
       // TENSOR RECONSTRUCTION
       clock.Start();
       MBI_INFO << "Teem Tensor reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
         "Teem Tensor reconstruction for %s", nodename.c_str()).toAscii());
       typedef mitk::TeemDiffusionTensor3DReconstructionImageFilter< 
         DiffusionPixelType, TTensorPixelType > TensorReconstructionImageFilterType;
       TensorReconstructionImageFilterType::Pointer tensorReconstructionFilter = 
         TensorReconstructionImageFilterType::New();
       tensorReconstructionFilter->SetInput( vols );
       if(!m_Controls->m_TensorEstimationTeemSigmaEdit->text().contains(QString("NaN")))
         tensorReconstructionFilter->SetSigma( m_Controls->m_TensorEstimationTeemSigmaEdit->text().toFloat() );
       switch(m_Controls->m_TensorEstimationTeemEstimationMethodCombo->currentIndex())
       {
         //  items << "LLS (Linear Least Squares)"
         //<< "MLE (Maximum Likelihood)"
         //<< "NLS (Nonlinear Least Squares)"
         //<< "WLS (Weighted Least Squares)";
       case 0:
         tensorReconstructionFilter->SetEstimationMethod(mitk::TeemTensorEstimationMethodsLLS);
         break;
       case 1:
         tensorReconstructionFilter->SetEstimationMethod(mitk::TeemTensorEstimationMethodsMLE);
         break;
       case 2:
         tensorReconstructionFilter->SetEstimationMethod(mitk::TeemTensorEstimationMethodsNLS);
         break;
       case 3:
         tensorReconstructionFilter->SetEstimationMethod(mitk::TeemTensorEstimationMethodsWLS);
         break;
       default:
         tensorReconstructionFilter->SetEstimationMethod(mitk::TeemTensorEstimationMethodsLLS);
       }
       tensorReconstructionFilter->SetNumIterations( m_Controls->m_TensorEstimationTeemNumItsSpin->value() );
       if(m_Controls->m_TensorEstimationManualThreashold->isChecked())
         tensorReconstructionFilter->SetConfidenceThreshold( m_Controls->m_TensorReconstructionThreasholdEdit_2->text().toDouble() );
       tensorReconstructionFilter->SetConfidenceFuzzyness( m_Controls->m_TensorEstimationTeemFuzzyEdit->text().toFloat() );
       tensorReconstructionFilter->SetMinPlausibleValue( m_Controls->m_TensorEstimationTeemMinValEdit->text().toDouble() );
       tensorReconstructionFilter->Update();
       clock.Stop();
       MBI_DEBUG << "took " << clock.GetMeanTime() << "s." ;
 
       // TENSORS TO DATATREE
       mitk::DataNode::Pointer node2=mitk::DataNode::New();
       node2->SetData( tensorReconstructionFilter->GetOutputItk() );
 
       QString newname;
       newname = newname.append(nodename.c_str());
       newname = newname.append("_dtix");
 
       SetDefaultNodeProperties(node2, newname.toStdString());
       nodes.push_back(node2);
 
       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)
   {
     MBI_INFO << ex ;
     return ;
   }
 }
 
 void QmitkTensorReconstructionView::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( "IsTensorVolume", mitk::BoolProperty::New( true ) );
 
 //mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
 //mitk::LevelWindow levelwindow;
 ////  levelwindow.SetAuto( image );
 //levWinProp->SetLevelWindow( levelwindow );
 //node->GetPropertyList()->SetProperty( "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 QmitkTensorReconstructionView::TensorsToDWI()
 {
   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("TensorImage").compare(node->GetData()->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     DoTensorsToDWI(set);
   }
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkTensorReconstructionView::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();
 
   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 QmitkTensorReconstructionView::DoTensorsToDWI
 (mitk::DataStorage::SetOfObjects::Pointer inImages) 
 {
   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
     {
 
       std::string nodename;
       (*itemiter)->GetStringProperty("name", nodename);
       
       mitk::TensorImage* vol = 
         static_cast<mitk::TensorImage*>((*itemiter)->GetData());
       
       ++itemiter;
 
       typedef float                                       TTensorPixelType;
       typedef itk::DiffusionTensor3D< TTensorPixelType >  TensorPixelType;
       typedef itk::Image< TensorPixelType, 3 >            TensorImageType;
 
       
       TensorImageType::Pointer itkvol = TensorImageType::New();
       mitk::CastToItkImage<TensorImageType>(vol, itkvol);
 
       typedef itk::TensorImageToDiffusionImageFilter< 
         TTensorPixelType, DiffusionPixelType > FilterType;
 
       FilterType::GradientListType gradientList;
 
       switch(m_Controls->m_TensorsToDWINumDirsSelect->currentIndex())
       {
       case 0:
         gradientList = MakeGradientList<12>();
         break;
       case 1:
         gradientList = MakeGradientList<42>();
         break;
       case 2:
         gradientList = MakeGradientList<92>();
         break;
       case 3:
         gradientList = MakeGradientList<162>();
         break;
       case 4:
         gradientList = MakeGradientList<252>();
         break;
       case 5:
         gradientList = MakeGradientList<362>();
         break;
       case 6:
         gradientList = MakeGradientList<492>();
         break;
       case 7:
         gradientList = MakeGradientList<642>();
         break;
       case 8:
         gradientList = MakeGradientList<812>();
         break;
       case 9:
         gradientList = MakeGradientList<1002>();
         break;
       default:
         gradientList = MakeGradientList<92>();
 
       }
 
       double bVal = m_Controls->m_TensorsToDWIBValueEdit->text().toDouble();
 
       // DWI ESTIMATION
       clock.Start();
       MBI_INFO << "DWI Estimation ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
         "DWI Estimation for %s", nodename.c_str()).toAscii());
       FilterType::Pointer filter = FilterType::New();
       filter->SetInput( itkvol );
       filter->SetBValue(bVal);  
       filter->SetGradientList(gradientList);  
       filter->SetNumberOfThreads(1);
       filter->Update();
       clock.Stop();
       MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
 
       itk::Vector<double,3> v;
       v[0] = 0; v[1] = 0; v[2] = 0;
       gradientList.push_back(v);
 
       // TENSORS TO DATATREE
       mitk::DiffusionImage<DiffusionPixelType>::Pointer image = mitk::DiffusionImage<DiffusionPixelType>::New();
       image->SetVectorImage( filter->GetOutput() );
       image->SetB_Value(bVal);
       image->SetDirections(gradientList);
       image->InitializeFromVectorImage();
       mitk::DataNode::Pointer node=mitk::DataNode::New();
       node->SetData( image );
 
       mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
 
       QString newname;
       newname = newname.append(nodename.c_str());
       newname = newname.append("_dwi");
       node->SetName(newname.toAscii());
 
       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)
   {
     MBI_INFO << ex ;
     return ;
   }
-}
\ No newline at end of file
+}
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
index 3ecac3b523..c9a8a6bd45 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
@@ -1,119 +1,120 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
 #define _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
 
 #include <QmitkFunctionality.h>
 
 #include <string>
 
 #include "ui_QmitkTensorReconstructionViewControls.h"
 
 #include "mitkDiffusionImage.h"
 
 #include <berryIPartListener.h>
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 typedef short DiffusionPixelType;
 
 struct TrSelListener;
 
 /*!
  * \ingroup org_mitk_gui_qt_tensorreconstruction_internal
  *
  * \brief QmitkTensorReconstructionView
  *
  * Document your class here.
  *
  * \sa QmitkFunctionality
  */
-class QmitkTensorReconstructionView : public QObject, public QmitkFunctionality
+class QmitkTensorReconstructionView : public QmitkFunctionality
 {
 
   friend struct TrSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   QmitkTensorReconstructionView();
+  QmitkTensorReconstructionView(const QmitkTensorReconstructionView& other);
   virtual ~QmitkTensorReconstructionView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
   /// \brief Called when the functionality is activated
   virtual void Activated();
 
   virtual void Deactivated();
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   static const int nrconvkernels;
 
 protected slots:
 
   void TensorsToDWI();
   void DoTensorsToDWI(mitk::DataStorage::SetOfObjects::Pointer inImages);
   void TeemCheckboxClicked();
   void Advanced1CheckboxClicked();
   void Advanced2CheckboxClicked();
   void ManualThresholdClicked();
   void MethodChoosen(int method);
   void Reconstruct(int method);
   void TeemReconstruction();
   void ItkReconstruction();
   void ItkTensorReconstruction
     (mitk::DataStorage::SetOfObjects::Pointer inImages);
   void TeemTensorReconstruction
     (mitk::DataStorage::SetOfObjects::Pointer inImages);
 
 
 protected:
 
   Ui::QmitkTensorReconstructionViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
   template<int ndirs>
   std::vector<itk::Vector<double,3> > MakeGradientList() ;
 
   template<int L>
   void TemplatedAnalyticalTensorReconstruction(mitk::DiffusionImage<DiffusionPixelType>* vols, 
     float lambda, std::string nodename, std::vector<mitk::DataNode::Pointer>* nodes, int normalization);
 
   void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
   berry::ISelectionListener::Pointer m_SelListener;
   berry::IStructuredSelection::ConstPointer m_CurrentSelection;
 
 };
 
 
 
 
 #endif // _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
 
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/mitkPluginActivator.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/mitkPluginActivator.cpp
new file mode 100644
index 0000000000..0c6187f534
--- /dev/null
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/mitkPluginActivator.cpp
@@ -0,0 +1,36 @@
+#include "mitkPluginActivator.h"
+
+#include <QtPlugin>
+
+
+#include "src/internal/QmitkDiffusionImagingPublicPerspective.h"
+
+#include "src/internal/QmitkQBallReconstructionView.h"
+#include "src/internal/QmitkPreprocessingView.h"
+#include "src/internal/QmitkDiffusionDicomImportView.h"
+#include "src/internal/QmitkDiffusionQuantificationView.h"
+#include "src/internal/QmitkTensorReconstructionView.h"
+#include "src/internal/QmitkControlVisualizationPropertiesView.h"
+
+namespace mitk {
+
+void PluginActivator::start(ctkPluginContext* context)
+{
+  BERRY_REGISTER_EXTENSION_CLASS(QmitkDiffusionImagingPublicPerspective, context)
+  
+  BERRY_REGISTER_EXTENSION_CLASS(QmitkQBallReconstructionView, context)
+  BERRY_REGISTER_EXTENSION_CLASS(QmitkPreprocessingView, context)
+  BERRY_REGISTER_EXTENSION_CLASS(QmitkDiffusionDicomImport, context)
+  BERRY_REGISTER_EXTENSION_CLASS(QmitkDiffusionQuantificationView, context)
+  BERRY_REGISTER_EXTENSION_CLASS(QmitkTensorReconstructionView, context)
+  BERRY_REGISTER_EXTENSION_CLASS(QmitkControlVisualizationPropertiesView, context)
+}
+
+void PluginActivator::stop(ctkPluginContext* context)
+{
+  Q_UNUSED(context)
+}
+
+}
+
+Q_EXPORT_PLUGIN2(org_mitk_gui_qt_diffusionimaging, mitk::PluginActivator)
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/mitkPluginActivator.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/mitkPluginActivator.h
new file mode 100644
index 0000000000..a34be34be4
--- /dev/null
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/mitkPluginActivator.h
@@ -0,0 +1,23 @@
+#ifndef MITKPLUGINACTIVATOR_H
+#define MITKPLUGINACTIVATOR_H
+
+#include <ctkPluginActivator.h>
+
+namespace mitk {
+
+class PluginActivator :
+  public QObject, public ctkPluginActivator
+{
+  Q_OBJECT
+  Q_INTERFACES(ctkPluginActivator)
+
+public:
+
+  void start(ctkPluginContext* context);
+  void stop(ctkPluginContext* context);
+
+}; // PluginActivator
+
+}
+
+#endif // MITKPLUGINACTIVATOR_H